home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / lib / hplip / hpssd.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2006-08-31  |  38.4 KB  |  1,493 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. __version__ = '7.5'
  5. __title__ = 'Services and Status Daemon'
  6. __doc__ = 'Provides various services to HPLIP client applications. Maintains persistant device status.'
  7. import sys
  8. import socket
  9. import os
  10. import os.path as os
  11. import signal
  12. import getopt
  13. import glob
  14. import time
  15. import select
  16. import popen2
  17. import threading
  18. import gettext
  19. import re
  20. import xml.parsers.expat as xml
  21. import fcntl
  22. import cStringIO
  23. import pwd
  24. from errno import EALREADY, EINPROGRESS, EWOULDBLOCK, ECONNRESET, ENOTCONN, ESHUTDOWN, EINTR, EISCONN
  25. from base.g import *
  26. from base.codes import *
  27. from base.msg import *
  28. from base import utils, slp, device
  29. from base.strings import string_table
  30. from prnt import cups
  31. alerts = { }
  32. fax_file = { }
  33.  
  34. class ServerDevice(object):
  35.     
  36.     def __init__(self, model = ''):
  37.         self.history = utils.RingBuffer(prop.history_size)
  38.         self.model = device.normalizeModelName(model)
  39.         self.cache = { }
  40.  
  41.  
  42. devices = { }
  43. model_cache = { }
  44. inter_pat = re.compile('%(.*)%', re.IGNORECASE)
  45.  
  46. def QueryString(id, typ = 0):
  47.     id = str(id)
  48.     
  49.     try:
  50.         s = string_table[id][typ]
  51.     except KeyError:
  52.         log.debug('String %s not found' % id)
  53.         raise Error(ERROR_STRING_QUERY_FAILED)
  54.  
  55.     if type(s) == type(''):
  56.         return s
  57.     
  58.     
  59.     try:
  60.         return s()
  61.     except:
  62.         raise Error(ERROR_STRING_QUERY_FAILED)
  63.  
  64.  
  65.  
  66. def initStrings():
  67.     cycles = 0
  68.     while True:
  69.         found = False
  70.         for s in string_table:
  71.             (short_string, long_string) = string_table[s]
  72.             short_replace = short_string
  73.             long_replace = long_string
  74.             
  75.             try:
  76.                 short_match = inter_pat.match(short_string).group(1)
  77.             except (AttributeError, TypeError):
  78.                 short_match = None
  79.  
  80.             if short_match is not None:
  81.                 found = True
  82.                 
  83.                 try:
  84.                     (short_replace, dummy) = string_table[short_match]
  85.                 except KeyError:
  86.                     log.error('String interpolation error: %s' % short_match)
  87.                 except:
  88.                     None<EXCEPTION MATCH>KeyError
  89.                 
  90.  
  91.             None<EXCEPTION MATCH>KeyError
  92.             
  93.             try:
  94.                 long_match = inter_pat.match(long_string).group(1)
  95.             except (AttributeError, TypeError):
  96.                 long_match = None
  97.  
  98.             if long_match is not None:
  99.                 found = True
  100.                 
  101.                 try:
  102.                     (dummy, long_replace) = string_table[long_match]
  103.                 except KeyError:
  104.                     log.error('String interpolation error: %s' % long_match)
  105.                 except:
  106.                     None<EXCEPTION MATCH>KeyError
  107.                 
  108.  
  109.             None<EXCEPTION MATCH>KeyError
  110.             if found:
  111.                 string_table[s] = (short_replace, long_replace)
  112.                 continue
  113.         
  114.         if not found:
  115.             break
  116.             continue
  117.         cycles += 1
  118.         if cycles > 1000:
  119.             break
  120.             continue
  121.  
  122.  
  123. class ModelParser:
  124.     
  125.     def __init__(self):
  126.         self.model = { }
  127.         self.cur_model = None
  128.         self.stack = []
  129.         self.model_found = False
  130.  
  131.     
  132.     def startElement(self, name, attrs):
  133.         if name in ('id', 'models'):
  134.             return None
  135.         elif name == 'model':
  136.             self.cur_model = str(attrs['name']).lower()
  137.             if self.cur_model == self.model_name:
  138.                 self.model_found = True
  139.                 self.stack = []
  140.             else:
  141.                 self.cur_model = None
  142.         elif self.cur_model is not None:
  143.             self.stack.append(str(name).lower())
  144.             if len(attrs):
  145.                 for a in attrs:
  146.                     self.stack.append(str(a).lower())
  147.                     
  148.                     try:
  149.                         i = int(attrs[a])
  150.                     except ValueError:
  151.                         i = str(attrs[a])
  152.  
  153.                     self.model[str('-'.join(self.stack))] = i
  154.                     self.stack.pop()
  155.                 
  156.             
  157.         
  158.  
  159.     
  160.     def endElement(self, name):
  161.         if name == 'model':
  162.             pass
  163.         elif name in ('id', 'models'):
  164.             return None
  165.         elif self.cur_model is not None:
  166.             self.stack.pop()
  167.         
  168.  
  169.     
  170.     def charData(self, data):
  171.         data = str(data).strip()
  172.         if data and self.model is not None and self.cur_model is not None and self.stack:
  173.             
  174.             try:
  175.                 i = int(data)
  176.             except ValueError:
  177.                 i = str(data)
  178.  
  179.             self.model[str('-'.join(self.stack))] = i
  180.         
  181.  
  182.     
  183.     def parseModels(self, model_name):
  184.         self.model_name = model_name
  185.         for g in [
  186.             prop.xml_dir,
  187.             os.path.join(prop.xml_dir, 'unreleased')]:
  188.             if os.path.exists(g):
  189.                 log.debug('Searching directory: %s' % g)
  190.                 for f in glob.glob(g + '/*.xml'):
  191.                     log.debug('Searching file: %s' % f)
  192.                     parser = xml.parsers.expat.ParserCreate()
  193.                     parser.StartElementHandler = self.startElement
  194.                     parser.EndElementHandler = self.endElement
  195.                     parser.CharacterDataHandler = self.charData
  196.                     parser.Parse(open(f).read(), True)
  197.                     if self.model_found:
  198.                         log.debug('Found')
  199.                         return self.model
  200.                         continue
  201.                 
  202.         
  203.         log.error('Not found')
  204.         raise Error(ERROR_UNSUPPORTED_MODEL)
  205.  
  206.  
  207.  
  208. def QueryModel(model_name):
  209.     model_name = device.normalizeModelName(model_name).lower()
  210.     log.debug('Query model: %s' % model_name)
  211.     if model_name in model_cache and model_cache[model_name]:
  212.         log.debug('Found')
  213.         return model_cache[model_name]
  214.     
  215.     mq = ModelParser().parseModels(model_name)
  216.     if mq:
  217.         model_cache[model_name] = mq
  218.     
  219.     if not mq:
  220.         pass
  221.     return { }
  222.  
  223. socket_map = { }
  224. loopback_trigger = None
  225.  
  226. def loop(timeout = 1.0, sleep_time = 0.10000000000000001):
  227.     while socket_map:
  228.         r = []
  229.         w = []
  230.         e = []
  231.         for fd, obj in socket_map.items():
  232.             if obj.readable():
  233.                 r.append(fd)
  234.             
  235.             if obj.writable():
  236.                 w.append(fd)
  237.                 continue
  238.         
  239.         if r == r and w == w:
  240.             pass
  241.         elif w == e:
  242.             time.sleep(timeout)
  243.         else:
  244.             
  245.             try:
  246.                 (r, w, e) = select.select(r, w, e, timeout)
  247.             except select.error:
  248.                 []
  249.                 err = []
  250.                 if err[0] != EINTR:
  251.                     raise Error(ERROR_INTERNAL)
  252.                 
  253.                 r = []
  254.                 w = []
  255.                 e = []
  256.             except:
  257.                 r
  258.  
  259.         for fd in r:
  260.             
  261.             try:
  262.                 obj = socket_map[fd]
  263.             except KeyError:
  264.                 []
  265.                 []
  266.                 continue
  267.             except:
  268.                 r
  269.  
  270.             
  271.             try:
  272.                 obj.handle_read_event()
  273.             continue
  274.             except Error:
  275.                 []
  276.                 e = []
  277.                 obj.handle_error(e)
  278.                 continue
  279.             
  280.  
  281.         
  282.         for fd in w:
  283.             
  284.             try:
  285.                 obj = socket_map[fd]
  286.             except KeyError:
  287.                 r<EXCEPTION MATCH>Error
  288.                 r<EXCEPTION MATCH>Error
  289.                 []
  290.                 continue
  291.             except:
  292.                 []
  293.  
  294.             
  295.             try:
  296.                 obj.handle_write_event()
  297.             except Error:
  298.                 []
  299.                 e = []
  300.                 obj.handle_error(e)
  301.             except:
  302.                 []
  303.  
  304.             time.sleep(sleep_time)
  305.         
  306.         continue
  307.         []
  308.  
  309.  
  310. class dispatcher:
  311.     connected = False
  312.     accepting = False
  313.     closing = False
  314.     addr = None
  315.     
  316.     def __init__(self, sock = None):
  317.         self.typ = ''
  318.         self.send_events = False
  319.         self.username = ''
  320.         if sock:
  321.             self.set_socket(sock)
  322.             self.socket.setblocking(0)
  323.             self.connected = True
  324.             
  325.             try:
  326.                 self.addr = sock.getpeername()
  327.             except socket.error:
  328.                 pass
  329.             except:
  330.                 None<EXCEPTION MATCH>socket.error
  331.             
  332.  
  333.         None<EXCEPTION MATCH>socket.error
  334.         self.socket = None
  335.  
  336.     
  337.     def add_channel(self):
  338.         socket_map[self._fileno] = self
  339.  
  340.     
  341.     def del_channel(self):
  342.         fd = self._fileno
  343.         if socket_map.has_key(fd):
  344.             del socket_map[fd]
  345.         
  346.  
  347.     
  348.     def create_socket(self, family, type):
  349.         self.family_and_type = (family, type)
  350.         self.socket = socket.socket(family, type)
  351.         self.socket.setblocking(0)
  352.         self._fileno = self.socket.fileno()
  353.         self.add_channel()
  354.  
  355.     
  356.     def set_socket(self, sock):
  357.         self.socket = sock
  358.         self._fileno = sock.fileno()
  359.         self.add_channel()
  360.  
  361.     
  362.     def set_reuse_addr(self):
  363.         
  364.         try:
  365.             self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, self.socket.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR) | 1)
  366.         except socket.error:
  367.             pass
  368.  
  369.  
  370.     
  371.     def readable(self):
  372.         return True
  373.  
  374.     
  375.     def writable(self):
  376.         return True
  377.  
  378.     
  379.     def listen(self, num):
  380.         self.accepting = True
  381.         return self.socket.listen(num)
  382.  
  383.     
  384.     def bind(self, addr):
  385.         self.addr = addr
  386.         return self.socket.bind(addr)
  387.  
  388.     
  389.     def connect(self, address):
  390.         self.connected = False
  391.         err = self.socket.connect_ex(address)
  392.         if err in (EINPROGRESS, EALREADY, EWOULDBLOCK):
  393.             return None
  394.         
  395.         if err in (0, EISCONN):
  396.             self.addr = address
  397.             self.connected = True
  398.             self.handle_connect()
  399.         else:
  400.             raise socket.error, err
  401.  
  402.     
  403.     def accept(self):
  404.         
  405.         try:
  406.             (conn, addr) = self.socket.accept()
  407.             return (conn, addr)
  408.         except socket.error:
  409.             why = None
  410.             if why[0] == EWOULDBLOCK:
  411.                 pass
  412.             else:
  413.                 raise socket.error, why
  414.         except:
  415.             why[0] == EWOULDBLOCK
  416.  
  417.  
  418.     
  419.     def send(self, data):
  420.         
  421.         try:
  422.             result = self.socket.send(data)
  423.             return result
  424.         except socket.error:
  425.             why = None
  426.             if why[0] == EWOULDBLOCK:
  427.                 return 0
  428.             else:
  429.                 raise socket.error, why
  430.             return 0
  431.  
  432.  
  433.     
  434.     def recv(self, buffer_size):
  435.         
  436.         try:
  437.             data = self.socket.recv(buffer_size)
  438.             if not data:
  439.                 self.handle_close()
  440.                 return ''
  441.             else:
  442.                 return data
  443.         except socket.error:
  444.             why = None
  445.             if why[0] in [
  446.                 ECONNRESET,
  447.                 ENOTCONN,
  448.                 ESHUTDOWN]:
  449.                 self.handle_close()
  450.                 return ''
  451.             else:
  452.                 raise socket.error, why
  453.         except:
  454.             why[0] in [
  455.                 ECONNRESET,
  456.                 ENOTCONN,
  457.                 ESHUTDOWN]
  458.  
  459.  
  460.     
  461.     def close(self):
  462.         self.del_channel()
  463.         self.socket.close()
  464.  
  465.     
  466.     def handle_read_event(self):
  467.         if self.accepting:
  468.             if not self.connected:
  469.                 self.connected = True
  470.             
  471.             self.handle_accept()
  472.         elif not self.connected:
  473.             self.handle_connect()
  474.             self.connected = True
  475.             self.handle_read()
  476.         else:
  477.             self.handle_read()
  478.  
  479.     
  480.     def handle_write_event(self):
  481.         if not self.connected:
  482.             self.handle_connect()
  483.             self.connected = True
  484.         
  485.         self.handle_write()
  486.  
  487.     
  488.     def handle_expt_event(self):
  489.         self.handle_expt()
  490.  
  491.     
  492.     def handle_error(self, e):
  493.         log.error('Error processing request.')
  494.         raise Error(ERROR_INTERNAL)
  495.  
  496.     
  497.     def handle_expt(self):
  498.         raise Error
  499.  
  500.     
  501.     def handle_read(self):
  502.         raise Error
  503.  
  504.     
  505.     def handle_write(self):
  506.         raise Error
  507.  
  508.     
  509.     def handle_connect(self):
  510.         raise Error
  511.  
  512.     
  513.     def handle_accept(self):
  514.         raise Error
  515.  
  516.     
  517.     def handle_close(self):
  518.         self.close()
  519.  
  520.  
  521.  
  522. class file_wrapper:
  523.     
  524.     def __init__(self, fd):
  525.         self.fd = fd
  526.  
  527.     
  528.     def recv(self, *args):
  529.         return os.read(self.fd, *args)
  530.  
  531.     
  532.     def send(self, *args):
  533.         return os.write(self.fd, *args)
  534.  
  535.     read = recv
  536.     write = send
  537.     
  538.     def close(self):
  539.         os.close(self.fd)
  540.  
  541.     
  542.     def fileno(self):
  543.         return self.fd
  544.  
  545.  
  546.  
  547. class file_dispatcher(dispatcher):
  548.     
  549.     def __init__(self, fd):
  550.         dispatcher.__init__(self, None)
  551.         self.connected = True
  552.         self.set_file(fd)
  553.         flags = fcntl.fcntl(fd, fcntl.F_GETFL, 0)
  554.         flags = flags | os.O_NONBLOCK
  555.         fcntl.fcntl(fd, fcntl.F_SETFL, flags)
  556.  
  557.     
  558.     def set_file(self, fd):
  559.         self._fileno = fd
  560.         self.socket = file_wrapper(fd)
  561.         self.add_channel()
  562.  
  563.  
  564.  
  565. class trigger(file_dispatcher):
  566.     
  567.     def __init__(self):
  568.         (r, w) = os.pipe()
  569.         self.trigger = w
  570.         file_dispatcher.__init__(self, r)
  571.         self.send_events = False
  572.         self.typ = 'trigger'
  573.  
  574.     
  575.     def readable(self):
  576.         return True
  577.  
  578.     
  579.     def writable(self):
  580.         return False
  581.  
  582.     
  583.     def handle_connect(self):
  584.         pass
  585.  
  586.     
  587.     def pull_trigger(self):
  588.         os.write(self.trigger, '.')
  589.  
  590.     
  591.     def handle_read(self):
  592.         self.recv(8192)
  593.  
  594.  
  595.  
  596. class hpssd_server(dispatcher):
  597.     
  598.     def __init__(self, ip, port):
  599.         self.ip = ip
  600.         self.send_events = False
  601.         if port != 0:
  602.             self.port = port
  603.         else:
  604.             self.port = socket.htons(0)
  605.         dispatcher.__init__(self)
  606.         self.typ = 'server'
  607.         self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
  608.         self.set_reuse_addr()
  609.         
  610.         try:
  611.             self.bind((ip, port))
  612.         except socket.error:
  613.             raise Error(ERROR_UNABLE_TO_BIND_SOCKET)
  614.  
  615.         prop.hpssd_port = self.port = self.socket.getsockname()[1]
  616.         self.listen(5)
  617.  
  618.     
  619.     def writable(self):
  620.         return False
  621.  
  622.     
  623.     def readable(self):
  624.         return self.accepting
  625.  
  626.     
  627.     def handle_accept(self):
  628.         
  629.         try:
  630.             (conn, addr) = self.accept()
  631.             log.debug('Connected to client: %s:%d (%d)' % (addr[0], addr[1], self._fileno))
  632.         except socket.error:
  633.             log.error('Socket error on accept()')
  634.             return None
  635.         except TypeError:
  636.             log.error('EWOULDBLOCK exception on accept()')
  637.             return None
  638.  
  639.         handler = hpssd_handler(conn, addr, self)
  640.  
  641.     
  642.     def handle_close(self):
  643.         dispatcher.handle_close(self)
  644.  
  645.  
  646.  
  647. class hpssd_handler(dispatcher):
  648.     
  649.     def __init__(self, conn, addr, server):
  650.         dispatcher.__init__(self, sock = conn)
  651.         self.addr = addr
  652.         self.in_buffer = ''
  653.         self.out_buffer = ''
  654.         self.server = server
  655.         self.fields = { }
  656.         self.payload = ''
  657.         self.signal_exit = False
  658.         self.typ = ''
  659.         self.send_events = False
  660.         self.username = ''
  661.         self.handlers = {
  662.             'probedevicesfiltered': self.handle_probedevicesfiltered,
  663.             'setalerts': self.handle_setalerts,
  664.             'testemail': self.handle_test_email,
  665.             'querymodel': self.handle_querymodel,
  666.             'modelquery': self.handle_modelquery,
  667.             'queryhistory': self.handle_queryhistory,
  668.             'querystring': self.handle_querystring,
  669.             'setvalue': self.handle_setvalue,
  670.             'getvalue': self.handle_getvalue,
  671.             'event': self.handle_event,
  672.             'registerguievent': self.handle_registerguievent,
  673.             'unregisterguievent': self.handle_unregisterguievent,
  674.             'exitevent': self.handle_exit,
  675.             'hpfaxbegin': self.handle_hpfaxbegin,
  676.             'hpfaxdata': self.handle_hpfaxdata,
  677.             'hpfaxend': self.handle_hpfaxend,
  678.             'faxgetdata': self.handle_faxgetdata,
  679.             'unknown': self.handle_unknown }
  680.  
  681.     
  682.     def handle_read(self):
  683.         log.debug('Reading data on channel (%d)' % self._fileno)
  684.         self.in_buffer = self.recv(prop.max_message_read)
  685.         log.debug(repr(self.in_buffer))
  686.         if not self.in_buffer:
  687.             return False
  688.         
  689.         remaining_msg = self.in_buffer
  690.         while True:
  691.             
  692.             try:
  693.                 (self.fields, self.payload, remaining_msg) = parseMessage(remaining_msg)
  694.             except Error:
  695.                 e = None
  696.                 err = e.opt
  697.                 log.warn('Message parsing error: %s (%d)' % (e.msg, err))
  698.                 self.out_buffer = self.handle_unknown(err)
  699.                 log.debug(self.out_buffer)
  700.                 return True
  701.  
  702.             msg_type = self.fields.get('msg', 'unknown').lower()
  703.             log.debug('Handling: %s %s %s' % ('*' * 20, msg_type, '*' * 20))
  704.             log.debug(repr(self.in_buffer))
  705.             
  706.             try:
  707.                 self.handlers.get(msg_type, self.handle_unknown)()
  708.             except Error:
  709.                 log.error('Unhandled exception during processing:')
  710.                 log.exception()
  711.  
  712.             self.handle_write()
  713.             if not remaining_msg:
  714.                 break
  715.                 continue
  716.         return True
  717.  
  718.     
  719.     def handle_unknown(self, err = ERROR_INVALID_MSG_TYPE):
  720.         pass
  721.  
  722.     
  723.     def handle_write(self):
  724.         if not self.out_buffer:
  725.             return None
  726.         
  727.         log.debug('Sending data on channel (%d)' % self._fileno)
  728.         log.debug(repr(self.out_buffer))
  729.         while self.out_buffer:
  730.             sent = self.send(self.out_buffer)
  731.             self.out_buffer = self.out_buffer[sent:]
  732.         if self.signal_exit:
  733.             self.handle_close()
  734.         
  735.  
  736.     
  737.     def __checkdevice(self, device_uri):
  738.         
  739.         try:
  740.             devices[device_uri]
  741.         except KeyError:
  742.             log.debug('New device: %s' % device_uri)
  743.             
  744.             try:
  745.                 (back_end, is_hp, bus, model, serial, dev_file, host, port) = device.parseDeviceURI(device_uri)
  746.             except Error:
  747.                 log.error('Invalid device URI')
  748.                 return ERROR_INVALID_DEVICE_URI
  749.  
  750.             devices[device_uri] = ServerDevice(model)
  751.  
  752.         return ERROR_SUCCESS
  753.  
  754.     
  755.     def handle_getvalue(self):
  756.         device_uri = self.fields.get('device-uri', '').replace('hpfax:', 'hp:')
  757.         value = ''
  758.         key = self.fields.get('key', '')
  759.         result_code = self._hpssd_handler__checkdevice(device_uri)
  760.         if result_code == ERROR_SUCCESS:
  761.             
  762.             try:
  763.                 value = devices[device_uri].cache[key]
  764.             except KeyError:
  765.                 value = ''
  766.                 result_code = ERROR_INTERNAL
  767.             except:
  768.                 None<EXCEPTION MATCH>KeyError
  769.             
  770.  
  771.         None<EXCEPTION MATCH>KeyError
  772.         self.out_buffer = buildResultMessage('GetValueResult', value, result_code)
  773.  
  774.     
  775.     def handle_setvalue(self):
  776.         device_uri = self.fields.get('device-uri', '').replace('hpfax:', 'hp:')
  777.         key = self.fields.get('key', '')
  778.         value = self.fields.get('value', '')
  779.         result_code = self._hpssd_handler__checkdevice(device_uri)
  780.         if result_code == ERROR_SUCCESS:
  781.             devices[device_uri].cache[key] = value
  782.         
  783.         self.out_buffer = buildResultMessage('SetValueResult', None, ERROR_SUCCESS)
  784.  
  785.     
  786.     def handle_queryhistory(self):
  787.         device_uri = self.fields.get('device-uri', '').replace('hpfax:', 'hp:')
  788.         payload = ''
  789.         result_code = self._hpssd_handler__checkdevice(device_uri)
  790.         self.out_buffer = buildResultMessage('QueryHistoryResult', payload, result_code)
  791.  
  792.     
  793.     def handle_querymodel(self):
  794.         device_uri = self.fields.get('device-uri', '').replace('hpfax:', 'hp:')
  795.         result_code = self._hpssd_handler__checkdevice(device_uri)
  796.         mq = { }
  797.         if result_code == ERROR_SUCCESS:
  798.             
  799.             try:
  800.                 (back_end, is_hp, bus, model, serial, dev_file, host, port) = device.parseDeviceURI(device_uri)
  801.             except Error:
  802.                 result_code = e.opt
  803.  
  804.             
  805.             try:
  806.                 mq = QueryModel(model)
  807.             except Error:
  808.                 e = None
  809.                 mq = { }
  810.                 result_code = e.opt
  811.             except:
  812.                 None<EXCEPTION MATCH>Error
  813.             
  814.  
  815.         None<EXCEPTION MATCH>Error
  816.         self.out_buffer = buildResultMessage('QueryModelResult', None, result_code, mq)
  817.  
  818.     
  819.     def handle_modelquery(self):
  820.         model = self.fields.get('model', '')
  821.         result_code = ERROR_SUCCESS
  822.         
  823.         try:
  824.             mq = QueryModel(model)
  825.         except Error:
  826.             e = None
  827.             mq = { }
  828.             result_code = e.opt
  829.  
  830.         self.out_buffer = buildResultMessage('ModelQueryResult', None, result_code, mq)
  831.  
  832.     
  833.     def handle_setalerts(self):
  834.         result_code = ERROR_SUCCESS
  835.         username = self.fields.get('username', '')
  836.         alerts[username] = {
  837.             'email-alerts': utils.to_bool(self.fields.get('email-alerts', '0')),
  838.             'email-from-address': self.fields.get('email-from-address', ''),
  839.             'email-to-addresses': self.fields.get('email-to-addresses', '') }
  840.         self.out_buffer = buildResultMessage('SetAlertsResult', None, result_code)
  841.  
  842.     
  843.     def handle_registerguievent(self):
  844.         username = self.fields.get('username', '')
  845.         typ = self.fields.get('type', 'unknown')
  846.         self.typ = typ
  847.         self.username = username
  848.         self.send_events = True
  849.         log.debug('Registering GUI for events: (%s, %s, %d)' % (username, typ, self._fileno))
  850.  
  851.     
  852.     def handle_unregisterguievent(self):
  853.         username = self.fields.get('username', '')
  854.         self.send_events = False
  855.  
  856.     
  857.     def handle_test_email(self):
  858.         result_code = ERROR_SUCCESS
  859.         username = self.fields.get('username', prop.username)
  860.         
  861.         try:
  862.             message = QueryString('email_test_message')
  863.         except Error:
  864.             message = ''
  865.  
  866.         
  867.         try:
  868.             subject = QueryString('email_test_subject')
  869.         except Error:
  870.             subject = ''
  871.  
  872.         result_code = self.sendEmail(username, subject, message, True)
  873.         self.out_buffer = buildResultMessage('TestEmailResult', None, result_code)
  874.  
  875.     
  876.     def handle_querystring(self):
  877.         payload = ''
  878.         result_code = ERROR_SUCCESS
  879.         string_id = self.fields['string-id']
  880.         
  881.         try:
  882.             payload = QueryString(string_id)
  883.         except Error:
  884.             log.error('String query failed for id %s' % string_id)
  885.             payload = None
  886.             result_code = ERROR_STRING_QUERY_FAILED
  887.  
  888.         self.out_buffer = buildResultMessage('QueryStringResult', payload, result_code)
  889.  
  890.     
  891.     def createHistory(self, device_uri, code, jobid = 0, username = prop.username):
  892.         result_code = self._hpssd_handler__checkdevice(device_uri)
  893.         if result_code == ERROR_SUCCESS:
  894.             
  895.             try:
  896.                 short_string = QueryString(code, 0)
  897.             except Error:
  898.                 (short_string, long_string) = ('', '')
  899.  
  900.             
  901.             try:
  902.                 long_string = QueryString(code, 1)
  903.             except Error:
  904.                 pass
  905.  
  906.             devices[device_uri].history.append(tuple(time.localtime()) + (jobid, username, code, short_string, long_string))
  907.             
  908.             try:
  909.                 prev_code = devices[device_uri].history.get()[-2][11]
  910.             except IndexError:
  911.                 return False
  912.  
  913.             return code == prev_code
  914.         
  915.  
  916.     
  917.     def handle_hpfaxbegin(self):
  918.         username = self.fields.get('username', prop.username)
  919.         job_id = self.fields.get('job-id', 0)
  920.         printer_name = self.fields.get('printer', '')
  921.         device_uri = self.fields.get('device-uri', '').replace('hp:', 'hpfax:')
  922.         title = self.fields.get('title', '')
  923.         log.debug('Creating data store for %s:%d' % (username, job_id))
  924.         fax_file[(username, job_id)] = cStringIO.StringIO()
  925.         result_code = ERROR_GUI_NOT_AVAILABLE
  926.         for handler in socket_map:
  927.             handler_obj = socket_map[handler]
  928.             if handler_obj.send_events and handler_obj.typ == 'fax' and handler_obj.username == username:
  929.                 handler_obj.out_buffer = buildMessage('EventGUI', '\n\n', {
  930.                     'job-id': job_id,
  931.                     'event-code': EVENT_FAX_RENDER_DISTANT_EARLY_WARNING,
  932.                     'event-type': 'event',
  933.                     'retry-timeout': 0,
  934.                     'device-uri': device_uri,
  935.                     'printer': printer_name,
  936.                     'title': title })
  937.                 loopback_trigger.pull_trigger()
  938.                 result_code = ERROR_SUCCESS
  939.                 continue
  940.         
  941.         self.out_buffer = buildResultMessage('HPFaxBeginResult', None, result_code)
  942.  
  943.     
  944.     def handle_hpfaxdata(self):
  945.         username = self.fields.get('username', prop.username)
  946.         job_id = self.fields.get('job-id', 0)
  947.         if self.payload and (username, job_id) in fax_file:
  948.             fax_file[(username, job_id)].write(self.payload)
  949.         
  950.         self.out_buffer = buildResultMessage('HPFaxDataResult', None, ERROR_SUCCESS)
  951.  
  952.     
  953.     def handle_hpfaxend(self):
  954.         username = self.fields.get('username', '')
  955.         job_id = self.fields.get('job-id', 0)
  956.         printer_name = self.fields.get('printer', '')
  957.         device_uri = self.fields.get('device-uri', '').replace('hp:', 'hpfax:')
  958.         title = self.fields.get('title', '')
  959.         job_size = self.fields.get('job-size', 0)
  960.         fax_file[(username, job_id)].seek(0)
  961.         for handler in socket_map:
  962.             handler_obj = socket_map[handler]
  963.             if handler_obj.send_events and handler_obj.typ == 'fax' and handler_obj.username == username:
  964.                 handler_obj.out_buffer = buildMessage('EventGUI', '\n\n', {
  965.                     'job-id': job_id,
  966.                     'event-code': EVENT_FAX_RENDER_COMPLETE,
  967.                     'event-type': 'event',
  968.                     'retry-timeout': 0,
  969.                     'device-uri': device_uri,
  970.                     'printer': printer_name,
  971.                     'title': title,
  972.                     'job-size': job_size })
  973.                 loopback_trigger.pull_trigger()
  974.                 break
  975.                 continue
  976.         
  977.         self.out_buffer = buildResultMessage('HPFaxEndResult', None, ERROR_SUCCESS)
  978.  
  979.     
  980.     def handle_faxgetdata(self):
  981.         result_code = ERROR_SUCCESS
  982.         username = self.fields.get('username', '')
  983.         job_id = self.fields.get('job-id', 0)
  984.         
  985.         try:
  986.             fax_file[(username, job_id)]
  987.         except KeyError:
  988.             result_code = ERROR_NO_DATA_AVAILABLE
  989.             data = ''
  990.  
  991.         data = fax_file[(username, job_id)].read(prop.max_message_len)
  992.         if not data:
  993.             result_code = ERROR_NO_DATA_AVAILABLE
  994.             log.debug('Deleting data store for %s:%d' % (username, job_id))
  995.             del fax_file[(username, job_id)]
  996.         
  997.         self.out_buffer = buildResultMessage('FaxGetDataResult', data, result_code)
  998.  
  999.     
  1000.     def handle_event(self):
  1001.         (gui_port, gui_host) = (None, None)
  1002.         event_type = self.fields.get('event-type', 'event')
  1003.         event_code = self.fields.get('event-code', 0)
  1004.         device_uri = self.fields.get('device-uri', '').replace('hpfax:', 'hp:')
  1005.         log.debug('Device URI: %s' % device_uri)
  1006.         
  1007.         try:
  1008.             error_string_short = QueryString(str(event_code), 0)
  1009.         except Error:
  1010.             (error_string_short, error_string_long) = ('', '')
  1011.  
  1012.         
  1013.         try:
  1014.             error_string_long = QueryString(str(event_code), 1)
  1015.         except Error:
  1016.             pass
  1017.  
  1018.         log.debug('Short/Long: %s/%s' % (error_string_short, error_string_long))
  1019.         job_id = self.fields.get('job-id', 0)
  1020.         
  1021.         try:
  1022.             username = self.fields['username']
  1023.         except KeyError:
  1024.             if job_id == 0:
  1025.                 username = prop.username
  1026.             else:
  1027.                 jobs = cups.getAllJobs()
  1028.                 for j in jobs:
  1029.                     if j.id == job_id:
  1030.                         username = j.user
  1031.                         break
  1032.                         continue
  1033.                 else:
  1034.                     username = prop.username
  1035.         except:
  1036.             job_id == 0
  1037.  
  1038.         no_fwd = self.fields.get('no-fwd', False)
  1039.         log.debug('Username (jobid): %s (%d)' % (username, job_id))
  1040.         retry_timeout = self.fields.get('retry-timeout', 0)
  1041.         user_alerts = alerts.get(username, { })
  1042.         dup_event = False
  1043.         if event_code <= EVENT_MAX_USER_EVENT:
  1044.             dup_event = self.createHistory(device_uri, event_code, job_id, username)
  1045.         
  1046.         pull = False
  1047.         if not no_fwd:
  1048.             for handler in socket_map:
  1049.                 handler_obj = socket_map[handler]
  1050.                 if handler_obj.send_events:
  1051.                     log.debug('Sending event to client: (%s, %s, %d)' % (handler_obj.username, handler_obj.typ, handler_obj._fileno))
  1052.                     pull = True
  1053.                     if handler_obj.typ == 'fax':
  1054.                         t = device_uri.replace('hp:', 'hpfax:')
  1055.                     else:
  1056.                         t = device_uri.replace('hpfax:', 'hp:')
  1057.                     handler_obj.out_buffer = buildMessage('EventGUI', '%s\n%s\n' % (error_string_short, error_string_long), {
  1058.                         'job-id': job_id,
  1059.                         'event-code': event_code,
  1060.                         'event-type': event_type,
  1061.                         'retry-timeout': retry_timeout,
  1062.                         'device-uri': t })
  1063.                     continue
  1064.             
  1065.             if pull:
  1066.                 loopback_trigger.pull_trigger()
  1067.             
  1068.             if event_code <= EVENT_MAX_USER_EVENT and user_alerts.get('email-alerts', False) and event_type == 'error' and not dup_event:
  1069.                 
  1070.                 try:
  1071.                     subject = QueryString('email_alert_subject') + device_uri
  1072.                 except Error:
  1073.                     subject = device_uri
  1074.  
  1075.                 message = '\n'.join([
  1076.                     device_uri,
  1077.                     time.strftime('%a, %d %b %Y %H:%M:%S', time.localtime()),
  1078.                     error_string_short,
  1079.                     error_string_long,
  1080.                     str(event_code)])
  1081.                 self.sendEmail(username, subject, message, False)
  1082.             
  1083.         
  1084.  
  1085.     
  1086.     def sendEmail(self, username, subject, message, wait):
  1087.         msg = cStringIO.StringIO()
  1088.         result_code = ERROR_SUCCESS
  1089.         user_alerts = alerts.get(username, { })
  1090.         from_address = user_alerts.get('email-from-address', '')
  1091.         to_addresses = user_alerts.get('email-to-addresses', from_address)
  1092.         t = time.strftime('%a, %d %b %Y %H:%M:%S +0000', time.gmtime())
  1093.         UUID = file('/proc/sys/kernel/random/uuid').readline().rstrip('\n')
  1094.         msg.write('Date: %s\n' % t)
  1095.         msg.write('From: <%s>\n' % from_address)
  1096.         msg.write('To: %s\n' % to_addresses)
  1097.         msg.write('Message-Id: <%s %s>\n' % (UUID, t))
  1098.         msg.write('Content-Type: text/plain\n')
  1099.         msg.write('Content-Transfer-Encoding: 7bit\n')
  1100.         msg.write('Mime-Version: 1.0\n')
  1101.         msg.write('Subject: %s\n' % subject)
  1102.         msg.write('\n')
  1103.         msg.write(message)
  1104.         email_message = msg.getvalue()
  1105.         log.debug(repr(email_message))
  1106.         mt = MailThread(email_message, from_address)
  1107.         mt.start()
  1108.         if wait:
  1109.             mt.join()
  1110.             result_code = mt.result
  1111.         
  1112.         return result_code
  1113.  
  1114.     
  1115.     def handle_probedevicesfiltered(self):
  1116.         payload = ''
  1117.         result_code = ERROR_SUCCESS
  1118.         num_devices = 0
  1119.         ret_devices = { }
  1120.         buses = self.fields.get('bus', 'cups,usb,par').split(',')
  1121.         format = self.fields.get('format', 'default')
  1122.         for b in buses:
  1123.             bus = b.lower().strip()
  1124.             if bus == 'net':
  1125.                 ttl = int(self.fields.get('ttl', 4))
  1126.                 timeout = int(self.fields.get('timeout', 5))
  1127.                 
  1128.                 try:
  1129.                     detected_devices = slp.detectNetworkDevices('224.0.1.60', 427, ttl, timeout)
  1130.                 except Error:
  1131.                     log.error('An error occured during network probe.')
  1132.  
  1133.                 for ip in detected_devices:
  1134.                     hn = detected_devices[ip].get('hn', '?UNKNOWN?')
  1135.                     num_devices_on_jd = detected_devices[ip].get('num_devices', 0)
  1136.                     num_ports_on_jd = detected_devices[ip].get('num_ports', 1)
  1137.                     if num_devices_on_jd > 0:
  1138.                         for port in range(num_ports_on_jd):
  1139.                             dev = detected_devices[ip].get('device%d' % (port + 1), '0')
  1140.                             if dev is not None and dev != '0':
  1141.                                 device_id = device.parseDeviceID(dev)
  1142.                                 model = device.normalizeModelName(device_id.get('MDL', '?UNKNOWN?'))
  1143.                                 if num_ports_on_jd == 1:
  1144.                                     device_uri = 'hp:/net/%s?ip=%s' % (model, ip)
  1145.                                 else:
  1146.                                     device_uri = 'hp:/net/%s?ip=%s&port=%d' % (model, ip, port + 1)
  1147.                                 device_filter = self.fields.get('filter', 'none')
  1148.                                 if device_filter in ('none', 'print'):
  1149.                                     include = True
  1150.                                 else:
  1151.                                     include = True
  1152.                                     
  1153.                                     try:
  1154.                                         fields = QueryModel(model)
  1155.                                     except Error:
  1156.                                         continue
  1157.  
  1158.                                     for f in device_filter.split(','):
  1159.                                         filter_type = int(fields.get('%s-type' % f.lower().strip(), 0))
  1160.                                         if filter_type == 0:
  1161.                                             include = False
  1162.                                             break
  1163.                                             continue
  1164.                                     
  1165.                                 if include:
  1166.                                     ret_devices[device_uri] = (model, hn)
  1167.                                 
  1168.                             include
  1169.                         
  1170.                 
  1171.             if bus in ('usb', 'par'):
  1172.                 
  1173.                 try:
  1174.                     prop.hpiod_port = int(file(os.path.join(prop.run_dir, 'hpiod.port'), 'r').read())
  1175.                 except:
  1176.                     prop.hpiod_port = 0
  1177.  
  1178.                 log.debug('Connecting to hpiod (%s:%d)...' % (prop.hpiod_host, prop.hpiod_port))
  1179.                 hpiod_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  1180.                 hpiod_sock.connect((prop.hpiod_host, prop.hpiod_port))
  1181.                 (fields, data, result_code) = xmitMessage(hpiod_sock, 'ProbeDevices', None, {
  1182.                     'bus': bus })
  1183.                 log.debug('Closing connection.')
  1184.                 hpiod_sock.close()
  1185.                 for d in detected_devices:
  1186.                     
  1187.                     try:
  1188.                         (back_end, is_hp, bus, model, serial, dev_file, host, port) = device.parseDeviceURI(d)
  1189.                     except Error:
  1190.                         [] if result_code != ERROR_SUCCESS else []
  1191.                         [] if result_code != ERROR_SUCCESS else []
  1192.                         continue
  1193.                     except:
  1194.                         [] if result_code != ERROR_SUCCESS else []
  1195.  
  1196.                     if is_hp:
  1197.                         device_filter = self.fields.get('filter', 'none')
  1198.                         include = True
  1199.                         if device_filter not in ('none', 'print'):
  1200.                             
  1201.                             try:
  1202.                                 fields = QueryModel(model)
  1203.                             except Error:
  1204.                                 [] if result_code != ERROR_SUCCESS else []
  1205.                                 [] if result_code != ERROR_SUCCESS else []
  1206.                                 continue
  1207.                             except:
  1208.                                 [] if result_code != ERROR_SUCCESS else []
  1209.  
  1210.                             for f in device_filter.split(','):
  1211.                                 filter_type = int(fields.get('%s-type' % f.lower().strip(), 0))
  1212.                                 if filter_type == 0:
  1213.                                     include = False
  1214.                                     break
  1215.                                     continue
  1216.                                 [] if result_code != ERROR_SUCCESS else []
  1217.                             
  1218.                         
  1219.                         if include:
  1220.                             ret_devices[d] = (model, '')
  1221.                         
  1222.                     include
  1223.                 
  1224.             if bus == 'cups':
  1225.                 cups_printers = cups.getPrinters()
  1226.                 x = len(cups_printers)
  1227.                 for p in cups_printers:
  1228.                     device_uri = p.device_uri
  1229.                     if p.device_uri != '':
  1230.                         device_filter = self.fields.get('filter', 'none')
  1231.                         
  1232.                         try:
  1233.                             (back_end, is_hp, bs, model, serial, dev_file, host, port) = device.parseDeviceURI(device_uri)
  1234.                         except Error:
  1235.                             log.warning('Inrecognized URI: %s' % device_uri)
  1236.                             continue
  1237.  
  1238.                         if not is_hp:
  1239.                             continue
  1240.                         
  1241.                         include = True
  1242.                         if device_filter not in ('none', 'print'):
  1243.                             
  1244.                             try:
  1245.                                 fields = QueryModel(model)
  1246.                             except Error:
  1247.                                 continue
  1248.  
  1249.                             for f in device_filter.split(','):
  1250.                                 filter_type = int(fields.get('%s-type' % f.lower().strip(), 0))
  1251.                                 if filter_type == 0:
  1252.                                     include = False
  1253.                                     break
  1254.                                     continue
  1255.                             
  1256.                         
  1257.                         if include:
  1258.                             ret_devices[device_uri] = (model, '')
  1259.                         
  1260.                     include
  1261.                 
  1262.         
  1263.         for d in ret_devices:
  1264.             num_devices += 1
  1265.             if format == 'default':
  1266.                 payload = ''.join([
  1267.                     payload,
  1268.                     d,
  1269.                     ',',
  1270.                     ret_devices[d][0],
  1271.                     '\n'])
  1272.                 continue
  1273.             if ret_devices[d][1] != '':
  1274.                 payload = ''.join([
  1275.                     payload,
  1276.                     'direct ',
  1277.                     d,
  1278.                     ' "HP ',
  1279.                     ret_devices[d][0],
  1280.                     '" "',
  1281.                     ret_devices[d][1],
  1282.                     '"\n'])
  1283.                 continue
  1284.             payload = ''.join([
  1285.                 payload,
  1286.                 'direct ',
  1287.                 d,
  1288.                 ' "HP ',
  1289.                 ret_devices[d][0],
  1290.                 '" "',
  1291.                 d,
  1292.                 '"\n'])
  1293.         
  1294.         self.out_buffer = buildResultMessage('ProbeDevicesFilteredResult', payload, result_code, {
  1295.             'num-devices': num_devices })
  1296.  
  1297.     
  1298.     def handle_exit(self):
  1299.         self.signal_exit = True
  1300.  
  1301.     
  1302.     def handle_messageerror(self):
  1303.         pass
  1304.  
  1305.     
  1306.     def writable(self):
  1307.         if not (self.out_buffer):
  1308.             pass
  1309.         return not (self.connected)
  1310.  
  1311.     
  1312.     def handle_close(self):
  1313.         log.debug('Closing channel (%d)' % self._fileno)
  1314.         self.connected = False
  1315.         self.close()
  1316.  
  1317.  
  1318.  
  1319. class MailThread(threading.Thread):
  1320.     
  1321.     def __init__(self, message, from_address):
  1322.         threading.Thread.__init__(self)
  1323.         self.message = message
  1324.         self.from_address = from_address
  1325.         self.result = ERROR_SUCCESS
  1326.  
  1327.     
  1328.     def run(self):
  1329.         log.debug('Starting Mail Thread...')
  1330.         sendmail = utils.which('sendmail')
  1331.         if sendmail:
  1332.             sendmail = os.path.join(sendmail, 'sendmail')
  1333.             sendmail += ' -t -r %s' % self.from_address
  1334.             log.debug(sendmail)
  1335.             (std_out, std_in, std_err) = popen2.popen3(sendmail)
  1336.             log.debug(repr(self.message))
  1337.             std_in.write(self.message)
  1338.             std_in.close()
  1339.             (r, w, e) = select.select([
  1340.                 std_err], [], [], 2.0)
  1341.             if r:
  1342.                 err = std_err.read()
  1343.                 if err:
  1344.                     log.error(repr(err))
  1345.                     self.result = ERROR_TEST_EMAIL_FAILED
  1346.                 
  1347.             
  1348.         else:
  1349.             log.error('Mail send failed. sendmail not found.')
  1350.             self.result = ERROR_TEST_EMAIL_FAILED
  1351.         log.debug('Exiting mail thread')
  1352.  
  1353.  
  1354.  
  1355. def reInit():
  1356.     initStrings()
  1357.  
  1358.  
  1359. def handleSIGHUP(signo, frame):
  1360.     log.info('SIGHUP')
  1361.     reInit()
  1362.  
  1363.  
  1364. def exitAllGUIs():
  1365.     pass
  1366.  
  1367. USAGE = [
  1368.     (__doc__, '', 'name', True),
  1369.     ('Usage: hpssd.py [OPTIONS]', '', 'summary', True),
  1370.     utils.USAGE_OPTIONS,
  1371.     ('Do not daemonize:', '-x', 'option', False),
  1372.     ('Port to listen on:', '-p<port> or --port=<port> (overrides value in /etc/hp/hplip.conf)', 'option', False),
  1373.     utils.USAGE_LOGGING1,
  1374.     utils.USAGE_LOGGING2,
  1375.     ('Run in debug mode:', '-g (same as options: -ldebug -x)', 'option', False),
  1376.     utils.USAGE_HELP]
  1377.  
  1378. def usage(typ = 'text'):
  1379.     if typ == 'text':
  1380.         utils.log_title(__title__, __version__)
  1381.     
  1382.     utils.format_text(USAGE, typ, __title__, 'hpssd.py', __version__)
  1383.     sys.exit(0)
  1384.  
  1385.  
  1386. def main(args):
  1387.     global loopback_trigger
  1388.     prop.prog = sys.argv[0]
  1389.     prop.daemonize = True
  1390.     
  1391.     try:
  1392.         (opts, args) = getopt.getopt(sys.argv[1:], 'l:xhp:g', [
  1393.             'level=',
  1394.             'help',
  1395.             'help-man',
  1396.             'help-rest',
  1397.             'port='])
  1398.     except getopt.GetoptError:
  1399.         usage()
  1400.  
  1401.     if os.getenv('HPLIP_DEBUG'):
  1402.         log.set_level('debug')
  1403.     
  1404.     for o, a in opts:
  1405.         if o in ('-l', '--logging'):
  1406.             log_level = a.lower().strip()
  1407.             if not log.set_level(log_level):
  1408.                 usage()
  1409.             
  1410.         log.set_level(log_level)
  1411.         if o == '-g':
  1412.             log.set_level('debug')
  1413.             prop.daemonize = False
  1414.             continue
  1415.         if o in ('-x',):
  1416.             prop.daemonize = False
  1417.             continue
  1418.         if o in ('-h', '--help'):
  1419.             usage()
  1420.             continue
  1421.         if o == '--help-rest':
  1422.             usage('rest')
  1423.             continue
  1424.         if o == '--help-man':
  1425.             usage('man')
  1426.             continue
  1427.         if o in ('-p', '--port'):
  1428.             
  1429.             try:
  1430.                 prop.hpssd_cfg_port = int(a)
  1431.             except ValueError:
  1432.                 log.error('Port must be a numeric value')
  1433.                 usage()
  1434.             except:
  1435.                 None<EXCEPTION MATCH>ValueError
  1436.             
  1437.  
  1438.         None<EXCEPTION MATCH>ValueError
  1439.     
  1440.     utils.log_title(__title__, __version__)
  1441.     prop.history_size = 32
  1442.     utils.get_pidfile_lock(os.path.join(prop.run_dir, 'hpssd.pid'))
  1443.     if prop.daemonize:
  1444.         utils.daemonize()
  1445.     
  1446.     log.set_module('hpssd')
  1447.     gettext.install('hplip')
  1448.     reInit()
  1449.     
  1450.     try:
  1451.         server = hpssd_server(prop.hpssd_host, prop.hpssd_cfg_port)
  1452.     except Error:
  1453.         e = None
  1454.         log.error('Server exited with error: %s' % e.msg)
  1455.         sys.exit(1)
  1456.  
  1457.     
  1458.     try:
  1459.         loopback_trigger = trigger()
  1460.     except Error:
  1461.         e = None
  1462.         log.error('Server exited with error: %s' % e.msg)
  1463.         sys.exit(1)
  1464.  
  1465.     os.umask(91)
  1466.     file(os.path.join(prop.run_dir, 'hpssd.port'), 'w').write('%d\n' % prop.hpssd_port)
  1467.     os.umask(63)
  1468.     log.debug('port=%d' % prop.hpssd_port)
  1469.     log.info('Listening on %s:%d' % (prop.hpssd_host, prop.hpssd_port))
  1470.     signal.signal(signal.SIGHUP, handleSIGHUP)
  1471.     
  1472.     try:
  1473.         log.debug('Starting async loop...')
  1474.         
  1475.         try:
  1476.             loop(timeout = 0.5)
  1477.         except KeyboardInterrupt:
  1478.             log.warn('Ctrl-C hit, exiting...')
  1479.         except Exception:
  1480.             log.exception()
  1481.  
  1482.         log.debug('Cleaning up...')
  1483.     finally:
  1484.         os.remove(os.path.join(prop.run_dir, 'hpssd.pid'))
  1485.         os.remove(os.path.join(prop.run_dir, 'hpssd.port'))
  1486.         server.close()
  1487.         return 0
  1488.  
  1489.  
  1490. if __name__ == '__main__':
  1491.     sys.exit(main(sys.argv[1:]))
  1492.  
  1493.