home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / lib / hplip / fax / fax.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2006-08-31  |  36.4 KB  |  1,335 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. from __future__ import generators
  5. import sys
  6. import os
  7. import os.path as os
  8. import mmap
  9. import struct
  10. import time
  11. import threading
  12. import Queue
  13. import socket
  14. from cStringIO import StringIO
  15. from base.g import *
  16. from base.codes import *
  17. from base import device, utils, status, pml, msg
  18. from base.kirbybase import KirbyBase
  19. from prnt import cups
  20.  
  21. try:
  22.     import coverpages
  23. except ImportError:
  24.     pass
  25.  
  26. PAGE_FLAG_NONE = 0
  27. PAGE_FLAG_NEW_PAGE = 1
  28. PAGE_FLAG_END_PAGE = 2
  29. PAGE_FLAG_NEW_DOC = 4
  30. PAGE_FLAG_END_DOC = 8
  31. PAGE_FLAG_END_STREAM = 16
  32. MAJOR_VER = 2
  33. MINOR_VER = 0
  34. MFPDTF_RASTER_BITMAP = 0
  35. MFPDTF_RASTER_GRAYMAP = 1
  36. MFPDTF_RASTER_MH = 2
  37. MFPDTF_RASTER_MR = 3
  38. MFPDTF_RASTER_MMR = 4
  39. MFPDTF_RASTER_RGB = 5
  40. MFPDTF_RASTER_YCC411 = 6
  41. MFPDTF_RASTER_JPEG = 7
  42. MFPDTF_RASTER_PCL = 8
  43. MFPDTF_RASTER_NOT = 9
  44. DT_UNKNOWN = 0
  45. DT_FAX_IMAGES = 1
  46. DT_SCANNED_IMAGES = 2
  47. DT_DIAL_STRINGS = 3
  48. DT_DEMO_PAGES = 4
  49. DT_SPEED_DIALS = 5
  50. DT_FAX_LOGS = 6
  51. DT_CFG_PARMS = 7
  52. DT_LANG_STRS = 8
  53. DT_JUNK_FAX_CSIDS = 9
  54. DT_REPORT_STRS = 10
  55. DT_FONTS = 11
  56. DT_TTI_BITMAP = 12
  57. DT_COUNTERS = 13
  58. DT_DEF_PARMS = 14
  59. DT_SCAN_OPTIONS = 15
  60. DT_FW_JOB_TABLE = 17
  61. RT_START_PAGE = 0
  62. RT_RASTER = 1
  63. RT_END_PAGE = 2
  64. FIXED_HEADER_SIZE = 8
  65. IMAGE_VARIANT_HEADER_SIZE = 10
  66. DIAL_STRINGS_VARIANT_HEADER_SIZE = 6
  67. FAX_IMAGE_VARIANT_HEADER_SIZE = 74
  68. SOP_RECORD_SIZE = 36
  69. RASTER_RECORD_SIZE = 4
  70. EOP_RECORD_SIZE = 12
  71. DIAL_STRING_RECORD_SIZE = 51
  72. PAGE_FLAG_NEW_PAGE = 1
  73. PAGE_FLAG_END_PAGE = 2
  74. PAGE_FLAG_NEW_DOC = 4
  75. PAGE_FLAG_END_DOC = 8
  76. PAGE_FLAG_END_STREAM = 16
  77. SRC_UNKNOWN = 0
  78. SRC_HOST = 2
  79. SRC_SCANNER = 5
  80. SRC_HOST_THEN_SCANNER = 6
  81. SRC_SCANNER_THEN_HOST = 7
  82. TTI_NONE = 0
  83. TTI_PREPENDED_TO_IMAGE = 1
  84. TTI_OVERLAYED_ON_IMAGE = 2
  85. RASTER_DATA_SIZE = 504
  86. STATUS_IDLE = 0
  87. STATUS_PROCESSING_FILES = 1
  88. STATUS_DIALING = 2
  89. STATUS_CONNECTING = 3
  90. STATUS_SENDING = 4
  91. STATUS_COMPLETED = 5
  92. STATUS_CREATING_COVER_PAGE = 6
  93. STATUS_ERROR = 7
  94. STATUS_BUSY = 8
  95. STATUS_CLEANUP = 9
  96. EVENT_FAX_SEND_CANCELED = 1
  97. FILE_HEADER_SIZE = 28
  98. PAGE_HEADER_SIZE = 24
  99.  
  100. class FaxAddressBook(KirbyBase):
  101.     
  102.     def __init__(self):
  103.         KirbyBase.__init__(self)
  104.         t = os.path.expanduser('~/.hplip.fab')
  105.         self._fab = os.path.expanduser('~/hpfax/fab.db')
  106.         fax_dir = os.path.expanduser('~/hpfax')
  107.         if not os.path.exists(fax_dir):
  108.             os.mkdir(fax_dir)
  109.         
  110.         if os.path.exists(t) and not os.path.exists(self._fab):
  111.             import shutil
  112.             shutil.move(t, self._fab)
  113.         
  114.         if not os.path.exists(self._fab):
  115.             log.debug('Creating new fax address book: %s' % self._fab)
  116.             self.create()
  117.         
  118.  
  119.     
  120.     def create(self):
  121.         return KirbyBase.create(self, self._fab, [
  122.             'name:str',
  123.             'title:str',
  124.             'firstname:str',
  125.             'lastname:str',
  126.             'fax:str',
  127.             'groups:str',
  128.             'notes:str'])
  129.  
  130.     
  131.     def filename(self):
  132.         return self._fab
  133.  
  134.     
  135.     def close(self):
  136.         return KirbyBase.close(self)
  137.  
  138.     
  139.     def insert(self, values):
  140.         return KirbyBase.insert(self, self._fab, values)
  141.  
  142.     
  143.     def insertBatch(self, batchRecords):
  144.         return KirbyBase.insertBatch(self, self._fab, batchRecords)
  145.  
  146.     
  147.     def update(self, fields, searchData, updates, filter = None, useRegExp = False):
  148.         return KirbyBase.update(self, self._fab, fields, searchData, updates, filter, useRegExp)
  149.  
  150.     
  151.     def delete(self, fields, searchData, useRegExp = False):
  152.         return KirbyBase.delete(self, self._fab, fields, searchData, useRegExp)
  153.  
  154.     
  155.     def select(self, fields, searchData, filter = None, useRegExp = False, sortFields = [], sortDesc = [], returnType = 'list', rptSettings = [
  156.         0,
  157.         False]):
  158.         return KirbyBase.select(self, self._fab, fields, searchData, filter, useRegExp, sortFields, sortDesc, returnType, rptSettings)
  159.  
  160.     
  161.     def pack(self):
  162.         return KirbyBase.pack(self, self._fab)
  163.  
  164.     
  165.     def validate(self):
  166.         return KirbyBase.validate(self, self._fab)
  167.  
  168.     
  169.     def drop(self):
  170.         return KirbyBase.drop(self, self._fab)
  171.  
  172.     
  173.     def getFieldNames(self):
  174.         return KirbyBase.getFieldNames(self, self._fab)
  175.  
  176.     
  177.     def getFieldTypes(self):
  178.         return KirbyBase.getFieldTypes(self, self._fab)
  179.  
  180.     
  181.     def len(self):
  182.         return KirbyBase.len(self, self._fab)
  183.  
  184.     
  185.     def GetEntryByRecno(self, recno):
  186.         return AddressBookEntry(self.select([
  187.             'recno'], [
  188.             recno])[0])
  189.  
  190.     
  191.     def AllRecords(self):
  192.         return self.select([
  193.             'recno'], [
  194.             '*'])
  195.  
  196.     
  197.     def AllRecordEntries(self):
  198.         return [ AddressBookEntry(rec) for rec in self.select([
  199.             'recno'], [
  200.             '*']) ]
  201.  
  202.     
  203.     def GroupEntries(self, group):
  204.         return _[1]
  205.  
  206.     
  207.     def AllGroups(self):
  208.         temp = { }
  209.         for abe in self.AllRecordEntries():
  210.             for g in abe.group_list:
  211.                 temp.setdefault(g)
  212.             
  213.         
  214.         return temp.keys()
  215.  
  216.     
  217.     def UpdateGroupEntries(self, group_name, member_entries):
  218.         for entry in self.AllRecordEntries():
  219.             if entry.name in member_entries:
  220.                 if group_name not in entry.group_list:
  221.                     entry.group_list.append(group_name)
  222.                     self.update([
  223.                         'recno'], [
  224.                         entry.recno], [
  225.                         ','.join(entry.group_list)], [
  226.                         'groups'])
  227.                 
  228.             group_name not in entry.group_list
  229.             if group_name in entry.group_list:
  230.                 entry.group_list.remove(group_name)
  231.                 self.update([
  232.                     'recno'], [
  233.                     entry.recno], [
  234.                     ','.join(entry.group_list)], [
  235.                     'groups'])
  236.                 continue
  237.         
  238.  
  239.     
  240.     def DeleteGroup(self, group_name):
  241.         for entry in self.AllRecordEntries():
  242.             if group_name in entry.group_list:
  243.                 entry.group_list.remove(group_name)
  244.                 self.update([
  245.                     'recno'], [
  246.                     entry.recno], [
  247.                     ','.join(entry.group_list)], [
  248.                     'groups'])
  249.                 continue
  250.         
  251.  
  252.  
  253.  
  254. class AddressBookEntry(object):
  255.     
  256.     def __init__(self, rec = None):
  257.         if rec is not None:
  258.             rec = [ '' for x in rec ]
  259.             (self.recno, self.name, self.title, self.firstname, self.lastname, self.fax, self.groups, self.notes) = rec
  260.             self.group_list = []
  261.             if len(self.groups):
  262.                 for g in self.groups.split(','):
  263.                     self.group_list.append(g.strip())
  264.                 
  265.             
  266.         
  267.  
  268.     
  269.     def __str__(self):
  270.         return 'Recno=%d, Name=%s, Title=%s, First=%s, Last=%s, Fax=%s, Groups=%s, Notes=%s\n' % (self.recno, self.name, self.title, self.firstname, self.lastname, self.fax, self.group_list, self.notes)
  271.  
  272.  
  273.  
  274. class FaxDevice(device.Device):
  275.     
  276.     def __init__(self, device_uri = None, printer_name = None, hpssd_sock = None, hpiod_sock = None, callback = None):
  277.         device.Device.__init__(self, device_uri, printer_name, hpssd_sock, hpiod_sock, callback)
  278.         self.send_fax_thread = None
  279.         self.upload_log_thread = None
  280.  
  281.     
  282.     def setPhoneNum(self, num):
  283.         return self.setPML(pml.OID_FAX_LOCAL_PHONE_NUM, str(num))
  284.  
  285.     
  286.     def getPhoneNum(self):
  287.         return utils.printable(str(self.getPML(pml.OID_FAX_LOCAL_PHONE_NUM)[1]))
  288.  
  289.     phone_num = property(getPhoneNum, setPhoneNum, doc = 'OID_FAX_LOCAL_PHONE_NUM')
  290.     
  291.     def setStationName(self, name):
  292.         return self.setPML(pml.OID_FAX_STATION_NAME, str(name))
  293.  
  294.     
  295.     def getStationName(self):
  296.         return utils.printable(str(self.getPML(pml.OID_FAX_STATION_NAME)[1]))
  297.  
  298.     station_name = property(getStationName, setStationName, doc = 'OID_FAX_STATION_NAME')
  299.     
  300.     def uploadLog(self):
  301.         if not self.isUloadLogActive():
  302.             self.upload_log_thread = UploadLogThread(self)
  303.             self.upload_log_thread.start()
  304.             return True
  305.         else:
  306.             return False
  307.  
  308.     
  309.     def isUploadLogActive(self):
  310.         if self.upload_log_thread is not None:
  311.             return self.upload_log_thread.isAlive()
  312.         else:
  313.             return False
  314.  
  315.     
  316.     def waitForUploadLogThread(self):
  317.         if self.upload_log_thread is not None and self.upload_log_thread.isAlive():
  318.             self.upload_log_thread.join()
  319.         
  320.  
  321.     
  322.     def sendFaxes(self, phone_num_list, fax_file_list, cover_message = '', cover_re = '', cover_func = None, printer_name = '', update_queue = None, event_queue = None):
  323.         if not self.isSendFaxActive():
  324.             self.send_fax_thread = FaxSendThread(self, phone_num_list, fax_file_list, cover_message, cover_re, cover_func, printer_name, update_queue, event_queue)
  325.             self.send_fax_thread.start()
  326.             return True
  327.         else:
  328.             return False
  329.  
  330.     
  331.     def isSendFaxActive(self):
  332.         if self.send_fax_thread is not None:
  333.             return self.send_fax_thread.isAlive()
  334.         else:
  335.             return False
  336.  
  337.     
  338.     def waitForSendFaxThread(self):
  339.         if self.send_fax_thread is not None and self.send_fax_thread.isAlive():
  340.             self.send_fax_thread.join()
  341.         
  342.  
  343.  
  344.  
  345. class UploadLogThread(threading.Thread):
  346.     
  347.     def __init__(self, dev):
  348.         threading.Thread.__init__(self)
  349.         self.dev = dev
  350.  
  351.     
  352.     def run(self):
  353.         STATE_DONE = 0
  354.         STATE_ABORT = 10
  355.         STATE_SUCCESS = 20
  356.         STATE_BUSY = 25
  357.         STATE_DEVICE_OPEN = 28
  358.         STATE_CHECK_IDLE = 30
  359.         STATE_REQUEST_START = 40
  360.         STATE_WAIT_FOR_ACTIVE = 50
  361.         STATE_UPLOAD_DATA = 60
  362.         STATE_DEVICE_CLOSE = 70
  363.         state = STATE_CHECK_IDLE
  364.         while state != STATE_DONE:
  365.             if state == STATE_ABORT:
  366.                 continue
  367.             if state == STATE_SUCCESS:
  368.                 continue
  369.             if state == STATE_BUSY:
  370.                 continue
  371.             if state == STATE_DEVICE_OPEN:
  372.                 state = STATE_REQUEST_START
  373.                 
  374.                 try:
  375.                     self.dev.open()
  376.                 except Error:
  377.                     e = None
  378.                     log.error('Unable to open device (%s).' % e.msg)
  379.                     state = STATE_ERROR
  380.  
  381.                 
  382.                 try:
  383.                     dev.setPML(pml.OID_UPLOAD_TIMEOUT, pml.DEFAULT_UPLOAD_TIMEOUT)
  384.                 except Error:
  385.                     state = STATE_ERROR
  386.                 except:
  387.                     None<EXCEPTION MATCH>Error
  388.                 
  389.  
  390.             None<EXCEPTION MATCH>Error
  391.             if state == STATE_CHECK_IDLE:
  392.                 state = STATE_REQUEST_START
  393.                 ul_state = self.getCfgUploadState()
  394.                 if ul_state != pml.UPDN_STATE_IDLE:
  395.                     state = STATE_BUSY
  396.                 
  397.             ul_state != pml.UPDN_STATE_IDLE
  398.             if state == STATE_REQUEST_START:
  399.                 state = STATE_WAIT_FOR_ACTIVE
  400.                 self.dev.setPML(pml.OID_FAX_CFG_UPLOAD_DATA_TYPE, pml.FAX_CFG_UPLOAD_DATA_TYPE_FAXLOGS)
  401.                 self.dev.setPML(pml.OID_DEVICE_CFG_UPLOAD, pml.UPDN_STATE_REQSTART)
  402.                 continue
  403.             if state == STATE_WAIT_FOR_ACTIVE:
  404.                 state = STATE_UPLOAD_DATA
  405.                 tries = 0
  406.                 while True:
  407.                     tries += 1
  408.                     ul_state = self.getCfgUploadState()
  409.                     if ul_state == pml.UPDN_STATE_XFERACTIVE:
  410.                         break
  411.                     
  412.                     if ul_state in (pml.UPDN_STATE_ERRORABORT, pml.UPDN_STATE_XFERDONE):
  413.                         log.error('Cfg upload aborted!')
  414.                         state = STATE_ERROR
  415.                         break
  416.                     
  417.                     if tries > 10:
  418.                         state = STATE_ERROR
  419.                         log.error('Unable to get into active state!')
  420.                         break
  421.                     
  422.                     time.sleep(0.5)
  423.                 continue
  424.             if state == STATE_UPLOAD_DATA:
  425.                 continue
  426.             if state == STATE_DEVICE_CLOSE:
  427.                 self.dev.close()
  428.                 continue
  429.  
  430.  
  431.  
  432. class FaxSendThread(threading.Thread):
  433.     
  434.     def __init__(self, dev, phone_num_list, fax_file_list, cover_message = '', cover_re = '', cover_func = None, printer_name = '', update_queue = None, event_queue = None):
  435.         threading.Thread.__init__(self)
  436.         self.dev = dev
  437.         self.phone_num_list = phone_num_list
  438.         self.fax_file_list = fax_file_list
  439.         self.update_queue = update_queue
  440.         self.event_queue = event_queue
  441.         self.cover_message = cover_message
  442.         self.cover_re = cover_re
  443.         self.cover_func = cover_func
  444.         self.current_printer = printer_name
  445.         self.stream = StringIO()
  446.         self.prev_update = ''
  447.         self.remove_temp_file = False
  448.  
  449.     
  450.     def run(self):
  451.         results = { }
  452.         STATE_DONE = 0
  453.         STATE_ABORTED = 10
  454.         STATE_SUCCESS = 20
  455.         STATE_BUSY = 25
  456.         STATE_READ_SENDER_INFO = 30
  457.         STATE_PRERENDER = 40
  458.         STATE_COUNT_PAGES = 50
  459.         STATE_NEXT_RECIPIENT = 60
  460.         STATE_COVER_PAGE = 70
  461.         STATE_SINGLE_FILE = 80
  462.         STATE_MERGE_FILES = 90
  463.         STATE_SINGLE_FILE = 100
  464.         STATE_SEND_FAX = 110
  465.         STATE_CLEANUP = 120
  466.         STATE_ERROR = 130
  467.         next_recipient = self.next_recipient_gen()
  468.         state = STATE_READ_SENDER_INFO
  469.         self.rendered_file_list = []
  470.         while state != STATE_DONE:
  471.             if self.check_for_cancel():
  472.                 state = STATE_ABORTED
  473.             
  474.             log.debug('STATE=(%d, 0, 0)' % state)
  475.             if state == STATE_ABORTED:
  476.                 log.error('Aborted by user.')
  477.                 self.write_queue((STATUS_IDLE, 0, ''))
  478.                 state = STATE_CLEANUP
  479.                 continue
  480.             if state == STATE_SUCCESS:
  481.                 log.debug('Success.')
  482.                 self.write_queue((STATUS_COMPLETED, 0, ''))
  483.                 state = STATE_CLEANUP
  484.                 continue
  485.             if state == STATE_ERROR:
  486.                 log.error('Error, aborting.')
  487.                 self.write_queue((STATUS_ERROR, 0, ''))
  488.                 state = STATE_CLEANUP
  489.                 continue
  490.             if state == STATE_BUSY:
  491.                 log.error('Device busy, aborting.')
  492.                 self.write_queue((STATUS_BUSY, 0, ''))
  493.                 state = STATE_CLEANUP
  494.                 continue
  495.             if state == STATE_READ_SENDER_INFO:
  496.                 log.debug('%s State: Get sender info' % '*' * 20)
  497.                 state = STATE_PRERENDER
  498.                 
  499.                 try:
  500.                     self.dev.open()
  501.                 except Error:
  502.                     e = None
  503.                     log.error('Unable to open device (%s).' % e.msg)
  504.                     state = STATE_ERROR
  505.                 else:
  506.                     
  507.                     try:
  508.                         self.sender_name = self.dev.station_name
  509.                         log.debug('Sender name=%s' % self.sender_name)
  510.                         self.sender_fax = self.dev.phone_num
  511.                         log.debug('Sender fax=%s' % self.sender_fax)
  512.                     except Error:
  513.                         log.error('PML get failed!')
  514.                         state = STATE_ERROR
  515.  
  516.                 finally:
  517.                     self.dev.close()
  518.  
  519.                 continue
  520.             if state == STATE_PRERENDER:
  521.                 log.debug('%s State: Pre-render non-G3 files' % '*' * 20)
  522.                 state = STATE_COUNT_PAGES
  523.                 cover_page_present = False
  524.                 log.debug(self.fax_file_list)
  525.                 for fax_file in self.fax_file_list:
  526.                     (fax_file_name, fax_file_type, fax_file_desc, fax_file_title, fax_file_pages) = fax_file
  527.                     if fax_file_type == 'application/hplip-fax':
  528.                         self.rendered_file_list.append((fax_file_name, 'application/hplip-fax', 'HP Fax', fax_file_title))
  529.                         log.debug('Processing pre-rendered file: %s (%d pages)' % (fax_file_name, fax_file_pages))
  530.                     elif fax_file_type == 'application/hplip-fax-coverpage':
  531.                         cover_page_present = True
  532.                         log.debug('Skipping coverpage')
  533.                     else:
  534.                         log.debug('Processing file: %s' % fax_file_name)
  535.                         (f, canceled) = self.render_file(fax_file_name, fax_file_title, fax_file_type)
  536.                         if canceled:
  537.                             state = STATE_ABORTED
  538.                         elif not f:
  539.                             state = STATE_ERROR
  540.                         else:
  541.                             log.debug('Rendered file into %s' % f)
  542.                             self.rendered_file_list.append((f, 'application/hplip-fax', 'HP Fax', fax_file_title))
  543.                     if self.check_for_cancel():
  544.                         state = STATE_ABORTED
  545.                         continue
  546.                 
  547.                 log.debug(self.rendered_file_list)
  548.                 continue
  549.             if state == STATE_COUNT_PAGES:
  550.                 log.debug('%s State: Get total page count' % '*' * 20)
  551.                 state = STATE_NEXT_RECIPIENT
  552.                 recipient_file_list = self.rendered_file_list[:]
  553.                 log.debug('Counting total pages...')
  554.                 self.job_total_pages = 0
  555.                 log.debug(recipient_file_list)
  556.                 i = 0
  557.                 for fax_file in recipient_file_list:
  558.                     fax_file_name = fax_file[0]
  559.                     log.debug('Processing file (counting pages): %s...' % fax_file_name)
  560.                     self.write_queue((STATUS_PROCESSING_FILES, self.job_total_pages, ''))
  561.                     if os.path.exists(fax_file_name):
  562.                         results[fax_file_name] = ERROR_SUCCESS
  563.                         fax_file_fd = file(fax_file_name, 'r')
  564.                         header = fax_file_fd.read(FILE_HEADER_SIZE)
  565.                         (magic, version, total_pages, hort_dpi, vert_dpi, page_size, resolution, encoding, reserved1, reserved2) = self.decode_fax_header(header)
  566.                         if magic != 'hplip_g3':
  567.                             log.error('Invalid file header. Bad magic.')
  568.                             results[fax_file_name] = ERROR_FAX_INVALID_FAX_FILE
  569.                             state = STATE_ERROR
  570.                             continue
  571.                         
  572.                         if not i:
  573.                             (job_hort_dpi, job_vert_dpi, job_page_size, job_resolution, job_encoding) = (hort_dpi, vert_dpi, page_size, resolution, encoding)
  574.                             i += 1
  575.                         elif job_hort_dpi != hort_dpi and job_vert_dpi != vert_dpi and job_page_size != page_size and job_resolution != resolution or job_encoding != encoding:
  576.                             log.error('Incompatible options for file: %s' % fax_file_name)
  577.                             results[fax_file_name] = ERROR_FAX_INCOMPATIBLE_OPTIONS
  578.                             state = STATE_ERROR
  579.                         
  580.                         log.debug('Magic=%s Ver=%d Pages=%d hDPI=%d vDPI=%d Size=%d Res=%d Enc=%d' % (magic, version, total_pages, hort_dpi, vert_dpi, page_size, resolution, encoding))
  581.                         self.job_total_pages += total_pages
  582.                         fax_file_fd.close()
  583.                     else:
  584.                         log.error('Unable to find HP Fax file: %s' % fax_file_name)
  585.                         results[fax_file_name] = ERROR_FAX_FILE_NOT_FOUND
  586.                         state = STATE_ERROR
  587.                         break
  588.                     if self.check_for_cancel():
  589.                         state = STATE_ABORTED
  590.                         break
  591.                         continue
  592.                 
  593.                 if cover_page_present:
  594.                     self.job_total_pages += 1
  595.                 
  596.                 log.debug('Total fax pages=%d' % self.job_total_pages)
  597.                 continue
  598.             if state == STATE_NEXT_RECIPIENT:
  599.                 log.debug('%s State: Next recipient' % '*' * 20)
  600.                 state = STATE_COVER_PAGE
  601.                 
  602.                 try:
  603.                     recipient = next_recipient.next()
  604.                     log.debug('Processing for recipient %s' % recipient.name)
  605.                 except StopIteration:
  606.                     state = STATE_SUCCESS
  607.                     log.debug('Last recipient.')
  608.                     continue
  609.  
  610.                 recipient_file_list = self.rendered_file_list[:]
  611.                 continue
  612.             if state == STATE_COVER_PAGE:
  613.                 log.debug('%s State: Render cover page' % '*' * 20)
  614.                 if self.job_total_pages > 1:
  615.                     state = STATE_MERGE_FILES
  616.                 else:
  617.                     state = STATE_SINGLE_FILE
  618.                 if cover_page_present:
  619.                     log.debug('Creating cover page for recipient: %s' % recipient.name)
  620.                     (fax_file, canceled) = self.render_cover_page(recipient)
  621.                     if canceled:
  622.                         state = STATE_ABORTED
  623.                     elif not fax_file:
  624.                         state = STATE_ERROR
  625.                     else:
  626.                         recipient_file_list.insert(0, (fax_file, 'application/hplip-fax', 'HP Fax', 'Cover Page'))
  627.                         log.debug('Cover page G3 file: %s' % fax_file)
  628.                         results[fax_file] = ERROR_SUCCESS
  629.                 
  630.             cover_page_present
  631.             if state == STATE_SINGLE_FILE:
  632.                 log.debug('%s State: Handle single file' % '*' * 20)
  633.                 state = STATE_SEND_FAX
  634.                 log.debug('Processing single file...')
  635.                 f = recipient_file_list[0][0]
  636.                 
  637.                 try:
  638.                     f_fd = file(f, 'r')
  639.                 except IOError:
  640.                     log.error('Unable to open fax file: %s' % f)
  641.                     state = STATE_ERROR
  642.  
  643.                 header = f_fd.read(FILE_HEADER_SIZE)
  644.                 (magic, version, total_pages, hort_dpi, vert_dpi, page_size, resolution, encoding, reserved1, reserved2) = self.decode_fax_header(header)
  645.                 results[f] = ERROR_SUCCESS
  646.                 if magic != 'hplip_g3':
  647.                     log.error('Invalid file header. Bad magic.')
  648.                     results[f] = ERROR_FAX_INVALID_FAX_FILE
  649.                     state = STATE_ERROR
  650.                 
  651.                 log.debug('Magic=%s Ver=%d Pages=%d hDPI=%d vDPI=%d Size=%d Res=%d Enc=%d' % (magic, version, total_pages, hort_dpi, vert_dpi, page_size, resolution, encoding))
  652.                 f_fd.close()
  653.                 continue
  654.             if state == STATE_MERGE_FILES:
  655.                 log.debug('%s State: Merge multiple files' % '*' * 20)
  656.                 log.debug(recipient_file_list)
  657.                 log.debug('Merging g3 files...')
  658.                 state = STATE_SEND_FAX
  659.                 self.remove_temp_file = True
  660.                 if self.job_total_pages:
  661.                     (f_fd, f) = utils.make_temp_file()
  662.                     log.debug('Temp file=%s' % f)
  663.                     data = struct.pack('>8sBIHHBBBII', 'hplip_g3', 0x1L, self.job_total_pages, job_hort_dpi, job_vert_dpi, job_page_size, job_resolution, job_encoding, 0x0L, 0x0L)
  664.                     os.write(f_fd, data)
  665.                     job_page_num = 1
  666.                     for fax_file in recipient_file_list:
  667.                         fax_file_name = fax_file[0]
  668.                         log.debug('Processing file: %s...' % fax_file_name)
  669.                         if results[fax_file_name] == ERROR_SUCCESS:
  670.                             fax_file_fd = file(fax_file_name, 'r')
  671.                             header = fax_file_fd.read(FILE_HEADER_SIZE)
  672.                             (magic, version, total_pages, hort_dpi, vert_dpi, page_size, resolution, encoding, reserved1, reserved2) = self.decode_fax_header(header)
  673.                             if magic != 'hplip_g3':
  674.                                 log.error('Invalid file header. Bad magic.')
  675.                                 state = STATE_ERROR
  676.                                 break
  677.                             
  678.                             log.debug('Magic=%s Ver=%d Pages=%d hDPI=%d vDPI=%d Size=%d Res=%d Enc=%d' % (magic, version, total_pages, hort_dpi, vert_dpi, page_size, resolution, encoding))
  679.                             for p in range(total_pages):
  680.                                 header = fax_file_fd.read(PAGE_HEADER_SIZE)
  681.                                 (page_num, ppr, rpp, bytes_to_read, thumbnail_bytes, reserved2) = self.decode_page_header(header)
  682.                                 if page_num == -1:
  683.                                     log.error('Page header error')
  684.                                     state - STATE_ERROR
  685.                                     break
  686.                                 
  687.                                 header = struct.pack('>IIIIII', job_page_num, ppr, rpp, bytes_to_read, thumbnail_bytes, 0x0L)
  688.                                 os.write(f_fd, header)
  689.                                 self.write_queue((STATUS_PROCESSING_FILES, job_page_num, ''))
  690.                                 log.debug('Page=%d PPR=%d RPP=%d BPP=%d Thumb=%s' % (page_num, ppr, rpp, bytes_to_read, thumbnail_bytes))
  691.                                 os.write(f_fd, fax_file_fd.read(bytes_to_read))
  692.                                 job_page_num += 1
  693.                             
  694.                             fax_file_fd.close()
  695.                             if self.check_for_cancel():
  696.                                 state = STATE_ABORTED
  697.                                 break
  698.                             
  699.                         self.check_for_cancel()
  700.                         log.error('Skipping file: %s' % fax_file_name)
  701.                     
  702.                     os.close(f_fd)
  703.                     log.debug('Total pages=%d' % self.job_total_pages)
  704.                 
  705.             self.job_total_pages
  706.             if state == STATE_SEND_FAX:
  707.                 log.debug('%s State: Send fax' % '*' * 20)
  708.                 state = STATE_NEXT_RECIPIENT
  709.                 FAX_SEND_STATE_DONE = 0
  710.                 FAX_SEND_STATE_ABORT = 10
  711.                 FAX_SEND_STATE_ERROR = 20
  712.                 FAX_SEND_STATE_BUSY = 25
  713.                 FAX_SEND_STATE_SUCCESS = 30
  714.                 FAX_SEND_STATE_DEVICE_OPEN = 40
  715.                 FAX_SEND_STATE_SET_TOKEN = 50
  716.                 FAX_SEND_STATE_EARLY_OPEN = 60
  717.                 FAX_SEND_STATE_SET_PARAMS = 70
  718.                 FAX_SEND_STATE_CHECK_IDLE = 80
  719.                 FAX_SEND_STATE_START_REQUEST = 90
  720.                 FAX_SEND_STATE_LATE_OPEN = 100
  721.                 FAX_SEND_STATE_SEND_DIAL_STRINGS = 110
  722.                 FAX_SEND_STATE_SEND_FAX_HEADER = 120
  723.                 FAX_SEND_STATE_SEND_PAGES = 130
  724.                 FAX_SEND_STATE_SEND_END_OF_STREAM = 140
  725.                 FAX_SEND_STATE_WAIT_FOR_COMPLETE = 150
  726.                 FAX_SEND_STATE_RESET_TOKEN = 160
  727.                 FAX_SEND_STATE_CLOSE_SESSION = 170
  728.                 monitor_state = False
  729.                 fax_send_state = FAX_SEND_STATE_DEVICE_OPEN
  730.                 while fax_send_state != FAX_SEND_STATE_DONE:
  731.                     if self.check_for_cancel():
  732.                         log.error('Fax send aborted.')
  733.                         fax_send_state = FAX_SEND_STATE_ABORT
  734.                     
  735.                     if monitor_state:
  736.                         fax_state = self.getFaxDownloadState()
  737.                         if fax_state not in (pml.UPDN_STATE_XFERACTIVE, pml.UPDN_STATE_XFERDONE):
  738.                             log.error('D/L error state=%d' % fax_state)
  739.                             fax_send_state = FAX_SEND_STATE_ERROR
  740.                             state = STATE_ERROR
  741.                         
  742.                     
  743.                     log.debug('STATE=(%d, %d, 0)' % (STATE_SEND_FAX, fax_send_state))
  744.                     if fax_send_state == FAX_SEND_STATE_ABORT:
  745.                         monitor_state = False
  746.                         fax_send_state = FAX_SEND_STATE_RESET_TOKEN
  747.                         state = STATE_ABORTED
  748.                         continue
  749.                     if fax_send_state == FAX_SEND_STATE_ERROR:
  750.                         log.error('Fax send error.')
  751.                         monitor_state = False
  752.                         fax_send_state = FAX_SEND_STATE_RESET_TOKEN
  753.                         state = STATE_ERROR
  754.                         continue
  755.                     if fax_send_state == FAX_SEND_STATE_BUSY:
  756.                         log.error('Fax device busy.')
  757.                         monitor_state = False
  758.                         fax_send_state = FAX_SEND_STATE_RESET_TOKEN
  759.                         state = STATE_BUSY
  760.                         continue
  761.                     if fax_send_state == FAX_SEND_STATE_SUCCESS:
  762.                         log.debug('Fax send success.')
  763.                         monitor_state = False
  764.                         fax_send_state = FAX_SEND_STATE_RESET_TOKEN
  765.                         state = STATE_NEXT_RECIPIENT
  766.                         continue
  767.                     if fax_send_state == FAX_SEND_STATE_DEVICE_OPEN:
  768.                         log.debug('%s State: Open device' % '*' * 20)
  769.                         fax_send_state = FAX_SEND_STATE_SET_TOKEN
  770.                         
  771.                         try:
  772.                             self.dev.open()
  773.                         except Error:
  774.                             e = None
  775.                             log.error('Unable to open device (%s).' % e.msg)
  776.                             fax_send_state = FAX_SEND_STATE_ERROR
  777.  
  778.                         if self.dev.device_state == DEVICE_STATE_NOT_FOUND:
  779.                             fax_send_state = FAX_SEND_STATE_ERROR
  780.                         
  781.                     self.dev.device_state == DEVICE_STATE_NOT_FOUND
  782.                     if fax_send_state == FAX_SEND_STATE_SET_TOKEN:
  783.                         log.debug('%s State: Acquire fax token' % '*' * 20)
  784.                         
  785.                         try:
  786.                             (result_code, token) = self.dev.getPML(pml.OID_FAX_TOKEN)
  787.                         except Error:
  788.                             log.debug('Unable to acquire fax token (1).')
  789.                             fax_send_state = FAX_SEND_STATE_EARLY_OPEN
  790.  
  791.                     None if result_code > pml.ERROR_MAX_OK else check_token == token
  792.                     if fax_send_state == FAX_SEND_STATE_EARLY_OPEN:
  793.                         log.debug('%s State: Early open' % '*' * 20)
  794.                         fax_send_state = FAX_SEND_STATE_CHECK_IDLE
  795.                         if self.dev.fax_type == FAX_TYPE_BLACK_SEND_EARLY_OPEN:
  796.                             log.debug('Opening fax channel.')
  797.                             
  798.                             try:
  799.                                 self.dev.openFax()
  800.                             except Error:
  801.                                 e = None
  802.                                 log.error('Unable to open channel (%s).' % e.msg)
  803.                                 fax_send_state = FAX_SEND_STATE_ERROR
  804.                             except:
  805.                                 None<EXCEPTION MATCH>Error
  806.                             
  807.  
  808.                         None<EXCEPTION MATCH>Error
  809.                         log.debug('Skipped.')
  810.                         continue
  811.                     if fax_send_state == FAX_SEND_STATE_CHECK_IDLE:
  812.                         log.debug('%s State: Check idle' % '*' * 20)
  813.                         fax_send_state = FAX_SEND_STATE_START_REQUEST
  814.                         dl_state = self.getFaxDownloadState()
  815.                         tx_status = self.getFaxJobTxStatus()
  816.                         rx_status = self.getFaxJobRxStatus()
  817.                         if dl_state == pml.UPDN_STATE_IDLE and dl_state == pml.UPDN_STATE_ERRORABORT or dl_state == pml.UPDN_STATE_XFERDONE:
  818.                             if tx_status == pml.FAXJOB_TX_STATUS_IDLE or tx_status == pml.FAXJOB_TX_STATUS_DONE:
  819.                                 pass
  820.                         None if rx_status == pml.FAXJOB_RX_STATUS_IDLE or rx_status == pml.FAXJOB_RX_STATUS_DONE else state == pml.UPDN_STATE_IDLE
  821.                         fax_send_state = FAX_SEND_STATE_BUSY
  822.                         continue
  823.                     if fax_send_state == FAX_SEND_STATE_START_REQUEST:
  824.                         log.debug('%s State: Request start' % '*' * 20)
  825.                         fax_send_state = FAX_SEND_STATE_SET_PARAMS
  826.                         dl_state = self.getFaxDownloadState()
  827.                         if dl_state == pml.UPDN_STATE_IDLE:
  828.                             self.dev.setPML(pml.OID_FAX_DOWNLOAD, pml.UPDN_STATE_REQSTART)
  829.                             time.sleep(1)
  830.                             log.debug('Waiting for active state...')
  831.                             i = 0
  832.                             while i < 10:
  833.                                 log.debug('Try: %d' % i)
  834.                                 
  835.                                 try:
  836.                                     dl_state = self.getFaxDownloadState()
  837.                                 except Error:
  838.                                     log.error('PML/SNMP error')
  839.                                     fax_send_state = FAX_SEND_STATE_ERROR
  840.                                     break
  841.  
  842.                                 if dl_state == pml.UPDN_STATE_XFERACTIVE:
  843.                                     break
  844.                                 
  845.                                 time.sleep(1)
  846.                                 self.dev.setPML(pml.OID_FAX_DOWNLOAD, pml.UPDN_STATE_REQSTART)
  847.                                 i += 1
  848.                             log.error('Could not get into active state!')
  849.                             fax_send_state = FAX_SEND_STATE_BUSY
  850.                             monitor_state = True
  851.                         else:
  852.                             log.error('Could not get into idle state!')
  853.                             fax_send_state = FAX_SEND_STATE_BUSY
  854.                     dl_state == pml.UPDN_STATE_IDLE
  855.                     if fax_send_state == FAX_SEND_STATE_SET_PARAMS:
  856.                         log.debug('%s State: Set params' % '*' * 20)
  857.                         fax_send_state = FAX_SEND_STATE_LATE_OPEN
  858.                         
  859.                         try:
  860.                             self.dev.setPML(pml.OID_DEV_DOWNLOAD_TIMEOUT, pml.DEFAULT_DOWNLOAD_TIMEOUT)
  861.                             self.dev.setPML(pml.OID_FAXJOB_TX_TYPE, pml.FAXJOB_TX_TYPE_HOST_ONLY)
  862.                         except Error:
  863.                             e = None
  864.                             log.error('PML/SNMP error (%s)' % e.msg)
  865.                             fax_send_state = FAX_SEND_STATE_ERROR
  866.                         except:
  867.                             None<EXCEPTION MATCH>Error
  868.                         
  869.  
  870.                     None<EXCEPTION MATCH>Error
  871.                     if fax_send_state == FAX_SEND_STATE_LATE_OPEN:
  872.                         log.debug('%s State: Late open' % '*' * 20)
  873.                         fax_send_state = FAX_SEND_STATE_SEND_DIAL_STRINGS
  874.                         if self.dev.fax_type == FAX_TYPE_BLACK_SEND_LATE_OPEN:
  875.                             log.debug('Opening fax channel.')
  876.                             
  877.                             try:
  878.                                 self.dev.openFax()
  879.                             except Error:
  880.                                 log.error('Unable to open channel.')
  881.                                 fax_send_state = FAX_SEND_STATE_ERROR
  882.                             except:
  883.                                 None<EXCEPTION MATCH>Error
  884.                             
  885.  
  886.                         None<EXCEPTION MATCH>Error
  887.                         log.debug('Skipped.')
  888.                         continue
  889.                     if fax_send_state == FAX_SEND_STATE_SEND_DIAL_STRINGS:
  890.                         log.debug('%s State: Send dial strings' % '*' * 20)
  891.                         fax_send_state = FAX_SEND_STATE_SEND_FAX_HEADER
  892.                         log.debug('Sending dial strings...')
  893.                         self.create_mfpdtf_fixed_header(DT_DIAL_STRINGS, True, PAGE_FLAG_NEW_DOC | PAGE_FLAG_END_DOC | PAGE_FLAG_END_STREAM)
  894.                         self.create_mfpdtf_dial_strings(recipient.fax)
  895.                         
  896.                         try:
  897.                             self.write_stream()
  898.                         except Error:
  899.                             log.error('Channel write error.')
  900.                             fax_send_state = FAX_SEND_STATE_ERROR
  901.                         except:
  902.                             None<EXCEPTION MATCH>Error
  903.                         
  904.  
  905.                     None<EXCEPTION MATCH>Error
  906.                     if fax_send_state == FAX_SEND_STATE_SEND_FAX_HEADER:
  907.                         log.debug('%s State: Send fax header' % '*' * 20)
  908.                         fax_send_state = FAX_SEND_STATE_SEND_PAGES
  909.                         
  910.                         try:
  911.                             ff = file(f, 'r')
  912.                         except IOError:
  913.                             log.error('Unable to read fax file.')
  914.                             fax_send_state = FAX_SEND_STATE_ERROR
  915.                             continue
  916.  
  917.                         
  918.                         try:
  919.                             header = ff.read(FILE_HEADER_SIZE)
  920.                         except IOError:
  921.                             log.error('Unable to read fax file.')
  922.                             fax_send_state = FAX_SEND_STATE_ERROR
  923.                             continue
  924.  
  925.                         (magic, version, total_pages, hort_dpi, vert_dpi, page_size, resolution, encoding, reserved1, reserved2) = self.decode_fax_header(header)
  926.                     None if magic != 'hplip_g3' else None<EXCEPTION MATCH>Error
  927.                     if fax_send_state == FAX_SEND_STATE_SEND_PAGES:
  928.                         log.debug('%s State: Send pages' % '*' * 20)
  929.                         fax_send_state = FAX_SEND_STATE_SEND_END_OF_STREAM
  930.                         page = StringIO()
  931.                         for p in range(total_pages):
  932.                             if self.check_for_cancel():
  933.                                 fax_send_state = FAX_SEND_STATE_ABORT
  934.                             
  935.                             if fax_send_state == FAX_SEND_STATE_ABORT:
  936.                                 break
  937.                             
  938.                             
  939.                             try:
  940.                                 header = ff.read(PAGE_HEADER_SIZE)
  941.                             except IOError:
  942.                                 log.error('Unable to read fax file.')
  943.                                 fax_send_state = FAX_SEND_STATE_ERROR
  944.                                 continue
  945.  
  946.                             (page_num, ppr, rpp, bytes_to_read, thumbnail_bytes, reserved2) = self.decode_page_header(header)
  947.                             log.debug('Page=%d PPR=%d RPP=%d BPP=%d Thumb=%d' % (page_num, ppr, rpp, bytes_to_read, thumbnail_bytes))
  948.                             page.write(ff.read(bytes_to_read))
  949.                             thumbnail = ff.read(thumbnail_bytes)
  950.                             page.seek(0)
  951.                             self.create_mfpdtf_fixed_header(DT_FAX_IMAGES, page_flags = PAGE_FLAG_NEW_PAGE)
  952.                             self.create_sop_record(page_num, hort_dpi, vert_dpi, ppr, rpp, encoding)
  953.                             
  954.                             try:
  955.                                 data = page.read(RASTER_DATA_SIZE)
  956.                             except IOError:
  957.                                 log.error('Unable to read fax file.')
  958.                                 fax_send_state = FAX_SEND_STATE_ERROR
  959.                                 continue
  960.  
  961.                             if data == '':
  962.                                 log.error('No data!')
  963.                                 fax_send_state = FAX_SEND_STATE_ERROR
  964.                                 continue
  965.                             
  966.                             self.create_raster_data_record(data)
  967.                             total_read = RASTER_DATA_SIZE
  968.                             while True:
  969.                                 data = page.read(RASTER_DATA_SIZE)
  970.                                 total_read += RASTER_DATA_SIZE
  971.                                 self.getFaxDownloadState()
  972.                                 if data == '':
  973.                                     self.create_eop_record(rpp)
  974.                                     
  975.                                     try:
  976.                                         self.write_stream()
  977.                                     except Error:
  978.                                         log.error('Channel write error.')
  979.                                         fax_send_state = FAX_SEND_STATE_ERROR
  980.  
  981.                                     break
  982.                                 else:
  983.                                     
  984.                                     try:
  985.                                         self.write_stream()
  986.                                     except Error:
  987.                                         log.error('Channel write error.')
  988.                                         fax_send_state = FAX_SEND_STATE_ERROR
  989.                                         break
  990.  
  991.                                 status = self.getFaxJobTxStatus()
  992.                                 while status == pml.FAXJOB_TX_STATUS_DIALING:
  993.                                     self.write_queue((STATUS_DIALING, 0, recipient.fax))
  994.                                     time.sleep(1.0)
  995.                                     if self.check_for_cancel():
  996.                                         fax_send_state = FAX_SEND_STATE_ABORT
  997.                                         break
  998.                                     
  999.                                     dl_state = self.getFaxDownloadState()
  1000.                                     if dl_state == pml.UPDN_STATE_ERRORABORT:
  1001.                                         fax_send_state = FAX_SEND_STATE_ERROR
  1002.                                         break
  1003.                                     
  1004.                                     status = self.getFaxJobTxStatus()
  1005.                                 if fax_send_state not in (FAX_SEND_STATE_ABORT, FAX_SEND_STATE_ERROR):
  1006.                                     while status == pml.FAXJOB_TX_STATUS_CONNECTING:
  1007.                                         self.write_queue((STATUS_CONNECTING, 0, recipient.fax))
  1008.                                         time.sleep(1.0)
  1009.                                         if self.check_for_cancel():
  1010.                                             fax_send_state = FAX_SEND_STATE_ABORT
  1011.                                             break
  1012.                                         
  1013.                                         dl_state = self.getFaxDownloadState()
  1014.                                         if dl_state == pml.UPDN_STATE_ERRORABORT:
  1015.                                             fax_send_state = FAX_SEND_STATE_ERROR
  1016.                                             break
  1017.                                         
  1018.                                         status = self.getFaxJobTxStatus()
  1019.                                 
  1020.                                 if status == pml.FAXJOB_TX_STATUS_TRANSMITTING:
  1021.                                     self.write_queue((STATUS_SENDING, page_num, recipient.fax))
  1022.                                 
  1023.                                 self.create_mfpdtf_fixed_header(DT_FAX_IMAGES, page_flags = 0)
  1024.                                 self.create_raster_data_record(data)
  1025.                                 if fax_send_state in (FAX_SEND_STATE_ABORT, FAX_SEND_STATE_ERROR):
  1026.                                     break
  1027.                                     continue
  1028.                             page.truncate(0)
  1029.                             page.seek(0)
  1030.                         
  1031.                     if fax_send_state == FAX_SEND_STATE_SEND_END_OF_STREAM:
  1032.                         log.debug('%s State: Send EOS' % '*' * 20)
  1033.                         fax_send_state = FAX_SEND_STATE_WAIT_FOR_COMPLETE
  1034.                         log.debug('End of stream...')
  1035.                         self.create_mfpdtf_fixed_header(DT_FAX_IMAGES, False, PAGE_FLAG_END_STREAM)
  1036.                         
  1037.                         try:
  1038.                             self.write_stream()
  1039.                         except Error:
  1040.                             log.error('Channel write error.')
  1041.                             fax_send_state = FAX_SEND_STATE_ERROR
  1042.  
  1043.                         monitor_state = False
  1044.                         continue
  1045.                     if fax_send_state == FAX_SEND_STATE_WAIT_FOR_COMPLETE:
  1046.                         log.debug('%s State: Wait for completion' % '*' * 20)
  1047.                         fax_send_state = FAX_SEND_STATE_WAIT_FOR_COMPLETE
  1048.                         time.sleep(1.0)
  1049.                         status = self.getFaxJobTxStatus()
  1050.                         if status == pml.FAXJOB_TX_STATUS_DIALING:
  1051.                             self.write_queue((STATUS_DIALING, 0, recipient.fax))
  1052.                         elif status == pml.FAXJOB_TX_STATUS_TRANSMITTING:
  1053.                             self.write_queue((STATUS_SENDING, page_num, recipient.fax))
  1054.                         elif status in (pml.FAXJOB_TX_STATUS_DONE, pml.FAXJOB_RX_STATUS_IDLE):
  1055.                             fax_send_state = FAX_SEND_STATE_RESET_TOKEN
  1056.                             state = STATE_NEXT_RECIPIENT
  1057.                         else:
  1058.                             self.write_queue((STATUS_SENDING, page_num, recipient.fax))
  1059.                     status == pml.FAXJOB_TX_STATUS_DIALING
  1060.                     if fax_send_state == FAX_SEND_STATE_RESET_TOKEN:
  1061.                         self.write_queue((STATUS_CLEANUP, 0, ''))
  1062.                         log.debug('%s State: Release fax token' % '*' * 20)
  1063.                         
  1064.                         try:
  1065.                             self.dev.setPML(pml.OID_FAX_TOKEN, '\x00' * 16)
  1066.                         except Error:
  1067.                             log.error('Unable to release fax token.')
  1068.  
  1069.                         fax_send_state = FAX_SEND_STATE_CLOSE_SESSION
  1070.                         continue
  1071.                     if fax_send_state == FAX_SEND_STATE_CLOSE_SESSION:
  1072.                         log.debug('%s State: Close session' % '*' * 20)
  1073.                         fax_send_state = FAX_SEND_STATE_DONE
  1074.                         log.debug('Closing session...')
  1075.                         
  1076.                         try:
  1077.                             mm.close()
  1078.                         except NameError:
  1079.                             pass
  1080.  
  1081.                         
  1082.                         try:
  1083.                             ff.close()
  1084.                         except NameError:
  1085.                             pass
  1086.  
  1087.                         if self.dev.fax_type == FAX_TYPE_BLACK_SEND_LATE_OPEN:
  1088.                             log.debug('Closing fax channel.')
  1089.                             self.dev.closeFax()
  1090.                         
  1091.                         self.dev.setPML(pml.OID_FAX_DOWNLOAD, pml.UPDN_STATE_IDLE)
  1092.                         time.sleep(1)
  1093.                         if self.dev.fax_type == FAX_TYPE_BLACK_SEND_EARLY_OPEN:
  1094.                             log.debug('Closing fax channel.')
  1095.                             self.dev.closeFax()
  1096.                         
  1097.                         self.dev.close()
  1098.                         continue
  1099.                 continue
  1100.             if state == STATE_CLEANUP:
  1101.                 log.debug('%s State: Cleanup' % '*' * 20)
  1102.                 if self.remove_temp_file:
  1103.                     log.debug('Removing merged file: %s' % f)
  1104.                     
  1105.                     try:
  1106.                         os.remove(f)
  1107.                         log.debug('Removed')
  1108.                     except OSError:
  1109.                         log.debug('Not found')
  1110.                     except:
  1111.                         None<EXCEPTION MATCH>OSError
  1112.                     
  1113.  
  1114.                 None<EXCEPTION MATCH>OSError
  1115.                 state = STATE_DONE
  1116.                 continue
  1117.  
  1118.     
  1119.     def next_recipient_gen(self):
  1120.         for a in self.phone_num_list:
  1121.             yield a
  1122.         
  1123.  
  1124.     
  1125.     def render_file(self, path, title, mime_type, force_single_page = False):
  1126.         all_pages = True
  1127.         page_range = ''
  1128.         page_set = 0
  1129.         nup = 1
  1130.         cups.resetOptions()
  1131.         if mime_type in [
  1132.             'application/x-cshell',
  1133.             'application/x-perl',
  1134.             'application/x-python',
  1135.             'application/x-shell',
  1136.             'text/plain']:
  1137.             cups.addOption('prettyprint')
  1138.         
  1139.         if nup > 1:
  1140.             cups.addOption('number-up=%d' % nup)
  1141.         
  1142.         if force_single_page:
  1143.             cups.addOption('page-ranges=1')
  1144.         
  1145.         sent_job_id = cups.printFile(self.current_printer, path, title)
  1146.         cups.resetOptions()
  1147.         log.debug('Job ID=%d' % sent_job_id)
  1148.         job_id = 0
  1149.         fax_file = ''
  1150.         complete = False
  1151.         end_time = time.time() + 90.0
  1152.         while time.time() < end_time:
  1153.             while self.event_queue.qsize():
  1154.                 
  1155.                 try:
  1156.                     event = self.event_queue.get(0)
  1157.                     code = event[0]
  1158.                     log.debug("Received event '%s'" % repr(event))
  1159.                     if code == EVENT_FAX_RENDER_COMPLETE:
  1160.                         (title, username, job_id, job_size) = event[1:5]
  1161.                         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  1162.                         
  1163.                         try:
  1164.                             sock.connect((prop.hpssd_host, prop.hpssd_port))
  1165.                         except socket.error:
  1166.                             log.error('Unable to contact HPLIP I/O (hpssd).')
  1167.                             return ('', True)
  1168.  
  1169.                         (fd, fax_file) = utils.make_temp_file()
  1170.                         log.debug('Transfering job %d (%d bytes)' % (job_id, job_size))
  1171.                         while True:
  1172.                             (fields, data, result_code) = msg.xmitMessage(sock, 'FaxGetData', None, {
  1173.                                 'username': username,
  1174.                                 'job-id': job_id })
  1175.                             if data and result_code == ERROR_SUCCESS:
  1176.                                 os.write(fd, data)
  1177.                                 continue
  1178.                             complete = True
  1179.                             break
  1180.                         os.close(fd)
  1181.                         sock.close()
  1182.                     elif code == EVENT_FAX_SEND_CANCELED:
  1183.                         log.debug('Cancel pressed!')
  1184.                         log.error('Render canceled. Canceling job #%d...' % sent_job_id)
  1185.                         cups.cancelJob(sent_job_id)
  1186.                         return ('', True)
  1187.                 continue
  1188.                 except Queue.Empty:
  1189.                     break
  1190.                     continue
  1191.                 
  1192.  
  1193.                 None<EXCEPTION MATCH>Queue.Empty
  1194.             if complete and sent_job_id == job_id:
  1195.                 break
  1196.             
  1197.             time.sleep(1)
  1198.         log.error('Timeout waiting for rendering. Canceling job #%d...' % sent_job_id)
  1199.         cups.cancelJob(sent_job_id)
  1200.         return ('', False)
  1201.         return (fax_file, False)
  1202.  
  1203.     
  1204.     def check_for_cancel(self):
  1205.         canceled = False
  1206.         while self.event_queue.qsize():
  1207.             
  1208.             try:
  1209.                 event = self.event_queue.get(0)
  1210.                 if event[0] == EVENT_FAX_SEND_CANCELED:
  1211.                     canceled = True
  1212.                     log.debug('Cancel pressed!')
  1213.             continue
  1214.             except Queue.Empty:
  1215.                 break
  1216.                 continue
  1217.             
  1218.  
  1219.             None<EXCEPTION MATCH>Queue.Empty
  1220.         return canceled
  1221.  
  1222.     
  1223.     def render_cover_page(self, a):
  1224.         log.debug('Creating cover page...')
  1225.         pdf = self.cover_func(page_size = coverpages.PAGE_SIZE_LETTER, total_pages = self.job_total_pages, recipient_name = a.name, recipient_phone = '', recipient_fax = a.fax, sender_name = self.sender_name, sender_phone = user_cfg.fax.voice_phone, sender_fax = self.sender_fax, sender_email = user_cfg.fax.email_address, regarding = self.cover_re, message = self.cover_message)
  1226.         log.debug('PDF File=%s' % pdf)
  1227.         (fax_file, canceled) = self.render_file(pdf, 'Cover Page', 'application/pdf', force_single_page = True)
  1228.         
  1229.         try:
  1230.             os.remove(pdf)
  1231.         except IOError:
  1232.             pass
  1233.  
  1234.         return (fax_file, canceled)
  1235.  
  1236.     
  1237.     def write_queue(self, message):
  1238.         if self.update_queue is not None and message != self.prev_update:
  1239.             self.update_queue.put(message)
  1240.             time.sleep(0)
  1241.             self.prev_update = message
  1242.         
  1243.  
  1244.     
  1245.     def getFaxDownloadState(self):
  1246.         (result_code, state) = self.dev.getPML(pml.OID_FAX_DOWNLOAD)
  1247.         log.debug('D/L State=%d (%s)' % (state, pml.UPDN_STATE_STR.get(state, 'Unknown')))
  1248.         return state
  1249.  
  1250.     
  1251.     def getFaxJobTxStatus(self):
  1252.         (result_code, status) = self.dev.getPML(pml.OID_FAXJOB_TX_STATUS)
  1253.         log.debug('Tx Status=%d (%s)' % (status, pml.FAXJOB_TX_STATUS_STR.get(status, 'Unknown')))
  1254.         return status
  1255.  
  1256.     
  1257.     def getFaxJobRxStatus(self):
  1258.         (result_code, status) = self.dev.getPML(pml.OID_FAXJOB_RX_STATUS)
  1259.         log.debug('Rx Status=%d (%s)' % (status, pml.FAXJOB_RX_STATUS_STR.get(status, 'Unknown')))
  1260.         return status
  1261.  
  1262.     
  1263.     def getCfgUploadState(self):
  1264.         (result_code, state) = self.dev.getPML(pml.OID_DEVICE_CFG_UPLOAD)
  1265.         log.debug('Cfg Upload State = %d (%s)' % (state, pml.UPDN_STATE_STR.get(state, 'Unknown')))
  1266.         return state
  1267.  
  1268.     
  1269.     def create_mfpdtf_fixed_header(self, data_type, send_variant = False, page_flags = 0):
  1270.         header_len = FIXED_HEADER_SIZE
  1271.         if send_variant:
  1272.             if data_type == DT_DIAL_STRINGS:
  1273.                 header_len += DIAL_STRINGS_VARIANT_HEADER_SIZE
  1274.             elif data_type == DT_FAX_IMAGES:
  1275.                 header_len += FAX_IMAGE_VARIANT_HEADER_SIZE
  1276.             
  1277.         
  1278.         self.stream.write(struct.pack('<IHBB', 0, header_len, data_type, page_flags))
  1279.  
  1280.     
  1281.     def create_mfpdtf_dial_strings(self, number):
  1282.         self.stream.write(struct.pack('<BBHH51s', MAJOR_VER, MINOR_VER, 1, 51, number[:51]))
  1283.  
  1284.     
  1285.     def adjust_fixed_header_block_size(self):
  1286.         size = self.stream.tell()
  1287.         self.stream.seek(0)
  1288.         self.stream.write(struct.pack('<I', size))
  1289.  
  1290.     
  1291.     def create_sop_record(self, page_num, hort_dpi, vert_dpi, ppr, rpp, encoding, bpp = 1):
  1292.         self.stream.write(struct.pack('<BBHHHIHHHHHHIHHHH', RT_START_PAGE, encoding, page_num, ppr, bpp, rpp, 0, hort_dpi, 0, vert_dpi, ppr, bpp, rpp, 0, hort_dpi, 0, vert_dpi))
  1293.  
  1294.     
  1295.     def create_eop_record(self, rpp):
  1296.         self.stream.write(struct.pack('<BBBBII', RT_END_PAGE, 0, 0, 0, rpp, 0))
  1297.  
  1298.     
  1299.     def create_raster_data_record(self, data):
  1300.         if not len(data) <= RASTER_DATA_SIZE:
  1301.             raise AssertionError
  1302.         self.stream.write(struct.pack('<BBH', RT_RASTER, 0, len(data)))
  1303.         self.stream.write(data)
  1304.  
  1305.     
  1306.     def create_mfpdtf_fax_header(self, total_pages):
  1307.         self.stream.write(struct.pack('<BBBHBI20s20s20sI', MAJOR_VER, MINOR_VER, SRC_HOST, total_pages, TTI_PREPENDED_TO_IMAGE, 0, '', '', '', 0))
  1308.  
  1309.     
  1310.     def write_stream(self):
  1311.         self.adjust_fixed_header_block_size()
  1312.         self.dev.writeFax(self.stream.getvalue())
  1313.         self.stream.truncate(0)
  1314.         self.stream.seek(0)
  1315.  
  1316.     
  1317.     def decode_fax_header(self, header):
  1318.         
  1319.         try:
  1320.             return struct.unpack('>8sBIHHBBBII', header)
  1321.         except struct.error:
  1322.             return (-1, -1, -1, -1, -1, -1, -1, -1, -1, -1)
  1323.  
  1324.  
  1325.     
  1326.     def decode_page_header(self, header):
  1327.         
  1328.         try:
  1329.             return struct.unpack('>IIIIII', header)
  1330.         except struct.error:
  1331.             return (-1, -1, -1, -1, -1, -1)
  1332.  
  1333.  
  1334.  
  1335.