tools v6.2.0

Updated for B&N new scheme, added obok plugin, and many minor fixes,

DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/DeDRM_App.pyw.bak

@@ -0,0 +1,635 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# DeDRM.pyw, version 6.0.1
+# Copyright 2010-2013 some_updates and Apprentice Alf
+
+# Revision history:
+#   6.0.0 - Release along with unified plugin
+#   6.0.1 - Bug Fixes for Windows App
+#   6.0.2 - Fixed problem with spaces in paths and the bat file
+#   6.0.3 - Fix for Windows non-ascii user names
+#   6.0.4 - Fix for other potential unicode problems
+#   6.0.5 - Fix typo
+#   6.2.0 - Update to match plugin and AppleScript
+
+__version__ = '6.2.0'
+
+import sys
+import os, os.path
+sys.path.append(os.path.join(sys.path[0],"lib"))
+import sys, os
+import codecs
+
+from argv_utils import add_cp65001_codec, set_utf8_default_encoding, unicode_argv
+add_cp65001_codec()
+set_utf8_default_encoding()
+
+
+import shutil
+import Tkinter
+from Tkinter import *
+import Tkconstants
+import tkFileDialog
+from scrolltextwidget import ScrolledText
+from activitybar import ActivityBar
+if sys.platform.startswith("win"):
+    from askfolder_ed import AskFolder
+import re
+import simpleprefs
+import traceback
+
+from Queue import Full
+from Queue import Empty
+from multiprocessing import Process, Queue
+
+from scriptinterface import decryptepub, decryptpdb, decryptpdf, decryptk4mobi
+
+
+# Wrap a stream so that output gets flushed immediately
+# and appended to shared queue
+class QueuedUTF8Stream:
+    def __init__(self, stream, q):
+        self.stream = stream
+        self.encoding = 'utf-8'
+        self.q = q
+    def write(self, data):
+        if isinstance(data,unicode):
+            data = data.encode('utf-8',"replace")
+        self.q.put(data)
+    def __getattr__(self, attr):
+        return getattr(self.stream, attr)
+
+class DrmException(Exception):
+    pass
+
+class MainApp(Tk):
+    def __init__(self, apphome, dnd=False, filenames=[]):
+        Tk.__init__(self)
+        self.withdraw()
+        self.dnd = dnd
+        self.apphome = apphome
+
+        # preference settings
+        # [dictionary key, file in preferences directory where info is stored]
+        description = [ ['pids'   , 'pidlist.txt'   ],
+                        ['serials', 'seriallist.txt'],
+                        ['sdrms'  , 'sdrmlist.txt'  ],
+                        ['outdir' , 'outdir.txt'    ]]
+        self.po = simpleprefs.SimplePrefs("DeDRM",description)
+        if self.dnd:
+            self.cd = ConvDialog(self)
+            prefs = self.getPreferences()
+            self.cd.doit(prefs, filenames)
+        else:
+            prefs = self.getPreferences()
+            self.pd = PrefsDialog(self, prefs)
+            self.cd = ConvDialog(self)
+            self.pd.show()
+
+    def getPreferences(self):
+        prefs = self.po.getPreferences()
+        prefdir = prefs['dir']
+        adeptkeyfile = os.path.join(prefdir,'adeptkey.der')
+        if not os.path.exists(adeptkeyfile):
+            import adobekey
+            try:
+                adobekey.getkey(adeptkeyfile)
+            except:
+                pass
+        kindlekeyfile = os.path.join(prefdir,'kindlekey.k4i')
+        if not os.path.exists(kindlekeyfile):
+            import kindlekey
+            try:
+                kindlekey.getkey(kindlekeyfile)
+            except:
+                traceback.print_exc()
+                pass
+        bnepubkeyfile = os.path.join(prefdir,'bnepubkey.b64')
+        if not os.path.exists(bnepubkeyfile):
+            import ignoblekey
+            try:
+                ignoblekey.getkey(bnepubkeyfile)
+            except:
+                traceback.print_exc()
+                pass
+        return prefs
+
+    def setPreferences(self, newprefs):
+        prefdir = self.po.prefdir
+        if 'adkfile' in newprefs:
+            dfile = newprefs['adkfile']
+            fname = os.path.basename(dfile)
+            nfile = os.path.join(prefdir,fname)
+            if os.path.isfile(dfile):
+                shutil.copyfile(dfile,nfile)
+        if 'bnkfile' in newprefs:
+            dfile = newprefs['bnkfile']
+            fname = os.path.basename(dfile)
+            nfile = os.path.join(prefdir,fname)
+            if os.path.isfile(dfile):
+                shutil.copyfile(dfile,nfile)
+        if 'kinfofile' in newprefs:
+            dfile = newprefs['kinfofile']
+            fname = os.path.basename(dfile)
+            nfile = os.path.join(prefdir,fname)
+            if os.path.isfile(dfile):
+                shutil.copyfile(dfile,nfile)
+        self.po.setPreferences(newprefs)
+        return
+
+    def alldone(self):
+        if not self.dnd:
+            self.pd.enablebuttons()
+        else:
+            self.destroy()
+
+class PrefsDialog(Toplevel):
+    def __init__(self, mainapp, prefs_array):
+        Toplevel.__init__(self, mainapp)
+        self.withdraw()
+        self.protocol("WM_DELETE_WINDOW", self.withdraw)
+        self.title("DeDRM " + __version__)
+        self.prefs_array = prefs_array
+        self.status = Tkinter.Label(self, text='Setting Preferences')
+        self.status.pack(fill=Tkconstants.X, expand=1)
+        body = Tkinter.Frame(self)
+        self.body = body
+        body.pack(fill=Tkconstants.X, expand=1)
+        sticky = Tkconstants.E + Tkconstants.W
+        body.grid_columnconfigure(1, weight=2)
+
+        Tkinter.Label(body, text='Adobe Key file (adeptkey.der)').grid(row=0, sticky=Tkconstants.E)
+        self.adkpath = Tkinter.Entry(body, width=50)
+        self.adkpath.grid(row=0, column=1, sticky=sticky)
+        prefdir = self.prefs_array['dir']
+        keyfile = os.path.join(prefdir,'adeptkey.der')
+        if os.path.isfile(keyfile):
+            path = keyfile
+            self.adkpath.insert(0, path)
+        button = Tkinter.Button(body, text="...", command=self.get_adkpath)
+        button.grid(row=0, column=2)
+
+        Tkinter.Label(body, text='Kindle Key file (kindlekey.k4i)').grid(row=1, sticky=Tkconstants.E)
+        self.kkpath = Tkinter.Entry(body, width=50)
+        self.kkpath.grid(row=1, column=1, sticky=sticky)
+        prefdir = self.prefs_array['dir']
+        keyfile = os.path.join(prefdir,'kindlekey.k4i')
+        if os.path.isfile(keyfile):
+            path = keyfile
+            self.kkpath.insert(1, path)
+        button = Tkinter.Button(body, text="...", command=self.get_kkpath)
+        button.grid(row=1, column=2)
+
+        Tkinter.Label(body, text='Barnes and Noble Key file (bnepubkey.b64)').grid(row=2, sticky=Tkconstants.E)
+        self.bnkpath = Tkinter.Entry(body, width=50)
+        self.bnkpath.grid(row=2, column=1, sticky=sticky)
+        prefdir = self.prefs_array['dir']
+        keyfile = os.path.join(prefdir,'bnepubkey.b64')
+        if os.path.isfile(keyfile):
+            path = keyfile
+            self.bnkpath.insert(2, path)
+        button = Tkinter.Button(body, text="...", command=self.get_bnkpath)
+        button.grid(row=2, column=2)
+
+        Tkinter.Label(body, text='Mobipocket PID list\n(8 or 10 characters, comma separated)').grid(row=3, sticky=Tkconstants.E)
+        self.pidnums = Tkinter.StringVar()
+        self.pidinfo = Tkinter.Entry(body, width=50, textvariable=self.pidnums)
+        if 'pids' in self.prefs_array:
+            self.pidnums.set(self.prefs_array['pids'])
+        self.pidinfo.grid(row=3, column=1, sticky=sticky)
+
+        Tkinter.Label(body, text='eInk Kindle Serial Number list\n(16 characters, comma separated)').grid(row=4, sticky=Tkconstants.E)
+        self.sernums = Tkinter.StringVar()
+        self.serinfo = Tkinter.Entry(body, width=50, textvariable=self.sernums)
+        if 'serials' in self.prefs_array:
+            self.sernums.set(self.prefs_array['serials'])
+        self.serinfo.grid(row=4, column=1, sticky=sticky)
+
+        Tkinter.Label(body, text='eReader data list\n(name:last 8 digits on credit card, comma separated)').grid(row=5, sticky=Tkconstants.E)
+        self.sdrmnums = Tkinter.StringVar()
+        self.sdrminfo = Tkinter.Entry(body, width=50, textvariable=self.sdrmnums)
+        if 'sdrms' in self.prefs_array:
+            self.sdrmnums.set(self.prefs_array['sdrms'])
+        self.sdrminfo.grid(row=5, column=1, sticky=sticky)
+
+        Tkinter.Label(body, text="Output Folder (if blank, use input ebook's folder)").grid(row=6, sticky=Tkconstants.E)
+        self.outpath = Tkinter.Entry(body, width=50)
+        self.outpath.grid(row=6, column=1, sticky=sticky)
+        if 'outdir' in self.prefs_array:
+            dpath = self.prefs_array['outdir']
+            self.outpath.insert(0, dpath)
+        button = Tkinter.Button(body, text="...", command=self.get_outpath)
+        button.grid(row=6, column=2)
+
+        Tkinter.Label(body, text='').grid(row=7, column=0, columnspan=2, sticky=Tkconstants.N)
+
+        Tkinter.Label(body, text='Alternatively Process an eBook').grid(row=8, column=0, columnspan=2, sticky=Tkconstants.N)
+
+        Tkinter.Label(body, text='Select an eBook to Process*').grid(row=9, sticky=Tkconstants.E)
+        self.bookpath = Tkinter.Entry(body, width=50)
+        self.bookpath.grid(row=9, column=1, sticky=sticky)
+        button = Tkinter.Button(body, text="...", command=self.get_bookpath)
+        button.grid(row=9, column=2)
+
+        Tkinter.Label(body, font=("Helvetica", "10", "italic"), text='*To DeDRM multiple ebooks simultaneously, set your preferences and quit.\nThen drag and drop ebooks or folders onto the DeDRM_Drop_Target').grid(row=10, column=1, sticky=Tkconstants.E)
+
+        Tkinter.Label(body, text='').grid(row=11, column=0, columnspan=2, sticky=Tkconstants.E)
+
+        buttons = Tkinter.Frame(self)
+        buttons.pack()
+        self.sbotton = Tkinter.Button(buttons, text="Set Prefs", width=14, command=self.setprefs)
+        self.sbotton.pack(side=Tkconstants.LEFT)
+
+        buttons.pack()
+        self.pbotton = Tkinter.Button(buttons, text="Process eBook", width=14, command=self.doit)
+        self.pbotton.pack(side=Tkconstants.LEFT)
+        buttons.pack()
+        self.qbotton = Tkinter.Button(buttons, text="Quit", width=14, command=self.quitting)
+        self.qbotton.pack(side=Tkconstants.RIGHT)
+        buttons.pack()
+
+    def disablebuttons(self):
+        self.sbotton.configure(state='disabled')
+        self.pbotton.configure(state='disabled')
+        self.qbotton.configure(state='disabled')
+
+    def enablebuttons(self):
+        self.sbotton.configure(state='normal')
+        self.pbotton.configure(state='normal')
+        self.qbotton.configure(state='normal')
+
+    def show(self):
+        self.deiconify()
+        self.tkraise()
+
+    def hide(self):
+        self.withdraw()
+
+    def get_outpath(self):
+        cpath = self.outpath.get()
+        if sys.platform.startswith("win"):
+            # tk_chooseDirectory is horribly broken for unicode paths
+            # on windows - bug has been reported but not fixed for years
+            # workaround by using our own unicode aware version
+            outpath = AskFolder(message="Choose the folder for DRM-free ebooks",
+                defaultLocation=cpath)
+        else:
+            outpath = tkFileDialog.askdirectory(
+                parent=None, title='Choose the folder for DRM-free ebooks',
+                initialdir=cpath, initialfile=None)
+        if outpath:
+            outpath = os.path.normpath(outpath)
+            self.outpath.delete(0, Tkconstants.END)
+            self.outpath.insert(0, outpath)
+        return
+
+    def get_adkpath(self):
+        cpath = self.adkpath.get()
+        adkpath = tkFileDialog.askopenfilename(initialdir = cpath, parent=None, title='Select Adept Key file',
+            defaultextension='.der', filetypes=[('Adept Key file', '.der'), ('All Files', '.*')])
+        if adkpath:
+            adkpath = os.path.normpath(adkpath)
+            self.adkpath.delete(0, Tkconstants.END)
+            self.adkpath.insert(0, adkpath)
+        return
+
+    def get_kkpath(self):
+        cpath = self.kkpath.get()
+        kkpath = tkFileDialog.askopenfilename(initialdir = cpath, parent=None, title='Select Kindle Key file',
+            defaultextension='.k4i', filetypes=[('Kindle Key file', '.k4i'), ('All Files', '.*')])
+        if kkpath:
+            kkpath = os.path.normpath(kkpath)
+            self.kkpath.delete(0, Tkconstants.END)
+            self.kkpath.insert(0, kkpath)
+        return
+
+    def get_bnkpath(self):
+        cpath = self.bnkpath.get()
+        bnkpath = tkFileDialog.askopenfilename(initialdir = cpath, parent=None, title='Select Barnes and Noble Key file',
+            defaultextension='.b64', filetypes=[('Barnes and Noble Key file', '.b64'), ('All Files', '.*')])
+        if bnkpath:
+            bnkpath = os.path.normpath(bnkpath)
+            self.bnkpath.delete(0, Tkconstants.END)
+            self.bnkpath.insert(0, bnkpath)
+        return
+
+    def get_bookpath(self):
+        cpath = self.bookpath.get()
+        bookpath = tkFileDialog.askopenfilename(parent=None, title='Select eBook for DRM Removal',
+            filetypes=[('All Files', '.*'),
+                    ('ePub Files','.epub'),
+                    ('Kindle','.azw'),
+                    ('Kindle','.azw1'),
+                    ('Kindle','.azw3'),
+                    ('Kindle','.azw4'),
+                    ('Kindle','.tpz'),
+                    ('Kindle','.mobi'),
+                    ('Kindle','.prc'),
+                    ('eReader','.pdb'),
+                    ('PDF','.pdf')],
+            initialdir=cpath)
+        if bookpath:
+            bookpath = os.path.normpath(bookpath)
+            self.bookpath.delete(0, Tkconstants.END)
+            self.bookpath.insert(0, bookpath)
+        return
+
+    def quitting(self):
+        self.master.destroy()
+
+    def setprefs(self):
+        # setting new prefereces
+        new_prefs = {}
+        prefdir = self.prefs_array['dir']
+        new_prefs['dir'] = prefdir
+        new_prefs['pids'] = self.pidinfo.get().replace(" ","")
+        new_prefs['serials'] = self.serinfo.get().replace(" ","")
+        new_prefs['sdrms'] = self.sdrminfo.get().strip().replace(", ",",")
+        new_prefs['outdir'] = self.outpath.get().strip()
+        adkpath = self.adkpath.get()
+        if os.path.dirname(adkpath) != prefdir:
+            new_prefs['adkfile'] = adkpath
+        bnkpath = self.bnkpath.get()
+        if os.path.dirname(bnkpath) != prefdir:
+            new_prefs['bnkfile'] = bnkpath
+        kkpath = self.kkpath.get()
+        if os.path.dirname(kkpath) != prefdir:
+            new_prefs['kindlefile'] = kkpath
+        self.master.setPreferences(new_prefs)
+        # and update internal copies
+        self.prefs_array['pids'] = new_prefs['pids']
+        self.prefs_array['serials'] = new_prefs['serials']
+        self.prefs_array['sdrms'] = new_prefs['sdrms']
+        self.prefs_array['outdir'] = new_prefs['outdir']
+
+    def doit(self):
+        self.disablebuttons()
+        filenames=[]
+        bookpath = self.bookpath.get()
+        bookpath = os.path.abspath(bookpath)
+        filenames.append(bookpath)
+        self.master.cd.doit(self.prefs_array,filenames)
+
+
+
+class ConvDialog(Toplevel):
+    def __init__(self, master, prefs_array={}, filenames=[]):
+        Toplevel.__init__(self, master)
+        self.withdraw()
+        self.protocol("WM_DELETE_WINDOW", self.withdraw)
+        self.title("DeDRM Processing")
+        self.master = master
+        self.apphome = self.master.apphome
+        self.prefs_array = prefs_array
+        self.filenames = filenames
+        self.interval = 50
+        self.p2 = None
+        self.q = Queue()
+        self.running = 'inactive'
+        self.numgood = 0
+        self.numbad = 0
+        self.status = Tkinter.Label(self, text='DeDRM processing...')
+        self.status.pack(fill=Tkconstants.X, expand=1)
+        body = Tkinter.Frame(self)
+        body.pack(fill=Tkconstants.X, expand=1)
+        sticky = Tkconstants.E + Tkconstants.W
+        body.grid_columnconfigure(1, weight=2)
+
+        Tkinter.Label(body, text='Activity Bar').grid(row=0, sticky=Tkconstants.E)
+        self.bar = ActivityBar(body, length=80, height=15, barwidth=5)
+        self.bar.grid(row=0, column=1, sticky=sticky)
+
+        msg1 = ''
+        self.stext = ScrolledText(body, bd=5, relief=Tkconstants.RIDGE, height=4, width=80, wrap=Tkconstants.WORD)
+        self.stext.grid(row=2, column=0, columnspan=2,sticky=sticky)
+        self.stext.insert(Tkconstants.END,msg1)
+
+        buttons = Tkinter.Frame(self)
+        buttons.pack()
+        self.qbutton = Tkinter.Button(buttons, text="Quit", width=14, command=self.quitting)
+        self.qbutton.pack(side=Tkconstants.BOTTOM)
+        self.status['text'] = ''
+
+        self.logfile = open(os.path.join(os.path.expanduser('~'),'DeDRM.log'),'w')
+
+    def show(self):
+        self.deiconify()
+        self.tkraise()
+
+    def hide(self):
+        self.withdraw()
+
+    def doit(self, prefs, filenames):
+        self.running = 'inactive'
+        self.prefs_array = prefs
+        self.filenames = filenames
+        self.show()
+        self.processBooks()
+
+    def conversion_done(self):
+        self.hide()
+        self.master.alldone()
+
+    def processBooks(self):
+        while self.running == 'inactive':
+            rscpath = self.prefs_array['dir']
+            filename = None
+            if len(self.filenames) > 0:
+                filename = self.filenames.pop(0)
+            if filename == None:
+                msg = 'Complete:  '
+                msg += 'Successes: %d, ' % self.numgood
+                msg += 'Failures: %d\n' % self.numbad
+                self.showCmdOutput(msg)
+                if self.numbad == 0:
+                    self.after(2000,self.conversion_done())
+                self.logfile.write("DeDRM v{0}: {1}".format(__version__,msg))
+                self.logfile.close()
+                return
+            infile = filename
+            bname = os.path.basename(infile)
+            msg = 'Processing: ' + bname + '...'
+            self.logfile.write("DeDRM v{0}: {1}\n".format(__version__,msg))
+            self.showCmdOutput(msg)
+            outdir = os.path.dirname(filename)
+            if 'outdir' in self.prefs_array:
+                dpath = self.prefs_array['outdir']
+                if dpath.strip() != '':
+                    outdir = dpath
+            rv = self.decrypt_ebook(infile, outdir, rscpath)
+            if rv == 0:
+                self.bar.start()
+                self.running = 'active'
+                self.processQueue()
+            else:
+                msg = 'Unknown File: ' + bname + '\n'
+                self.logfile.write("DeDRM v{0}: {1}".format(__version__,msg))
+                self.showCmdOutput(msg)
+                self.numbad += 1
+
+    def quitting(self):
+        # kill any still running subprocess
+        self.running = 'stopped'
+        if self.p2 != None:
+            if (self.p2.exitcode == None):
+                self.p2.terminate()
+        self.conversion_done()
+
+    # post output from subprocess in scrolled text widget
+    def showCmdOutput(self, msg):
+        if msg and msg !='':
+            if sys.platform.startswith('win'):
+                msg = msg.replace('\r\n','\n')
+            self.stext.insert(Tkconstants.END,msg)
+            self.stext.yview_pickplace(Tkconstants.END)
+        return
+
+    # read from subprocess pipe without blocking
+    # invoked every interval via the widget "after"
+    # option being used, so need to reset it for the next time
+    def processQueue(self):
+        if self.p2 == None:
+            # nothing to wait for so just return
+            return
+        poll = self.p2.exitcode
+        #print "processing", poll
+        done = False
+        text = ''
+        while not done:
+            try:
+                data = self.q.get_nowait()
+                text += data
+            except Empty:
+                done = True
+        if text != '':
+            self.logfile.write(text)
+        if poll != None:
+            self.bar.stop()
+            if poll == 0:
+                msg = 'Success\n'
+                self.numgood += 1
+            else:
+                msg = 'Failed\n'
+                self.numbad += 1
+            self.p2.join()
+            self.logfile.write("DeDRM v{0}: {1}\n".format(__version__,msg))
+            self.showCmdOutput(msg)
+            self.p2 = None
+            self.running = 'inactive'
+            self.after(50,self.processBooks)
+            return
+        # make sure we get invoked again by event loop after interval
+        self.stext.after(self.interval,self.processQueue)
+        return
+
+    def decrypt_ebook(self, infile, outdir, rscpath):
+        q = self.q
+        rv = 1
+        name, ext = os.path.splitext(os.path.basename(infile))
+        ext = ext.lower()
+        if ext == '.epub':
+            self.p2 = Process(target=processEPUB, args=(q, infile, outdir, rscpath))
+            self.p2.start()
+            return 0
+        if ext == '.pdb':
+            self.p2 = Process(target=processPDB, args=(q, infile, outdir, rscpath))
+            self.p2.start()
+            return 0
+        if ext in ['.azw', '.azw1', '.azw3', '.azw4', '.prc', '.mobi', '.tpz']:
+            self.p2 = Process(target=processK4MOBI,args=(q, infile, outdir, rscpath))
+            self.p2.start()
+            return 0
+        if ext == '.pdf':
+            self.p2 = Process(target=processPDF, args=(q, infile, outdir, rscpath))
+            self.p2.start()
+            return 0
+        return rv
+
+
+# child process starts here
+def processK4MOBI(q, infile, outdir, rscpath):
+    add_cp65001_codec()
+    set_utf8_default_encoding()
+    sys.stdout = QueuedUTF8Stream(sys.stdout, q)
+    sys.stderr = QueuedUTF8Stream(sys.stderr, q)
+    rv = decryptk4mobi(infile, outdir, rscpath)
+    sys.exit(rv)
+
+# child process starts here
+def processPDF(q, infile, outdir, rscpath):
+    add_cp65001_codec()
+    set_utf8_default_encoding()
+    sys.stdout = QueuedUTF8Stream(sys.stdout, q)
+    sys.stderr = QueuedUTF8Stream(sys.stderr, q)
+    rv = decryptpdf(infile, outdir, rscpath)
+    sys.exit(rv)
+
+# child process starts here
+def processEPUB(q, infile, outdir, rscpath):
+    add_cp65001_codec()
+    set_utf8_default_encoding()
+    sys.stdout = QueuedUTF8Stream(sys.stdout, q)
+    sys.stderr = QueuedUTF8Stream(sys.stderr, q)
+    rv = decryptepub(infile, outdir, rscpath)
+    sys.exit(rv)
+
+# child process starts here
+def processPDB(q, infile, outdir, rscpath):
+    add_cp65001_codec()
+    set_utf8_default_encoding()
+    sys.stdout = QueuedUTF8Stream(sys.stdout, q)
+    sys.stderr = QueuedUTF8Stream(sys.stderr, q)
+    rv = decryptpdb(infile, outdir, rscpath)
+    sys.exit(rv)
+
+
+def main():
+    argv=unicode_argv()
+    apphome = os.path.dirname(argv[0])
+    apphome = os.path.abspath(apphome)
+
+    # windows may pass a spurious quoted null string as argv[1] from bat file
+    # simply work around this until we can figure out a better way to handle things
+    if sys.platform.startswith('win') and len(argv) == 2:
+        temp = argv[1]
+        temp = temp.strip('"')
+        temp = temp.strip()
+        if temp == '':
+            argv.pop()
+
+    if len(argv) == 1:
+        filenames = []
+        dnd = False
+
+    else : # processing books via drag and drop
+        dnd = True
+        # build a list of the files to be processed
+        # note all filenames and paths have been utf-8 encoded
+        infilelst = argv[1:]
+        filenames = []
+        for infile in infilelst:
+            infile = infile.replace('"','')
+            infile = os.path.abspath(infile)
+            if os.path.isdir(infile):
+                bpath = infile
+                filelst = os.listdir(infile)
+                for afile in filelst:
+                    if not afile.startswith('.'):
+                        filepath = os.path.join(bpath,afile)
+                        if os.path.isfile(filepath):
+                            filenames.append(filepath)
+            else :
+                afile = os.path.basename(infile)
+                if not afile.startswith('.'):
+                    if os.path.isfile(infile):
+                        filenames.append(infile)
+
+    # start up gui app
+    app = MainApp(apphome, dnd, filenames)
+    app.mainloop()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/DeDRM_app.pyw

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-# DeDRM.pyw, version 6.0.1
+# DeDRM.pyw
 # Copyright 2010-2013 some_updates and Apprentice Alf
 
 # Revision history:
@@ -11,8 +11,9 @@
 #   6.0.3 - Fix for Windows non-ascii user names
 #   6.0.4 - Fix for other potential unicode problems
 #   6.0.5 - Fix typo
+#   6.2.0 - Update to match plugin and AppleScript
 
-__version__ = '6.0.8'
+__version__ = '6.2.0'
 
 import sys
 import os, os.path
@@ -104,6 +105,14 @@ class MainApp(Tk):
             except:
                 traceback.print_exc()
                 pass
+        bnepubkeyfile = os.path.join(prefdir,'bnepubkey.b64')
+        if not os.path.exists(bnepubkeyfile):
+            import ignoblekey
+            try:
+                ignoblekey.getkey(bnepubkeyfile)
+            except:
+                traceback.print_exc()
+                pass
         return prefs
 
     def setPreferences(self, newprefs):

DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/lib/DeDRM_Barnes and Noble Key_Help.htm

@@ -22,7 +22,24 @@ li {margin-top: 0.5em}
 
 <p>If you have upgraded from an earlier version of the plugin, any existing Barnes and Noble keys will have been automatically imported, so you might not need to do any more configuration. Continue reading for key generation and management instructions.</p>
 
-<h3>Creating New Keys:</h3>
+<h3>Changes at Barnes & Noble</h3>
+
+<p>In mid-2014, Barnes & Noble changed the way they generated encryption keys. Instead of deriving the key from the user's name and credit card number, they started generating a random key themselves, sending that key through to devices when they connected to the Barnes & Noble servers. This means that some users will find that no combination of their name and CC# will work in decrypting their ebooks.</p>
+
+<p>There is a work-around. Barnes & Noble’s desktop app NOOK Study generates a log file that contains the encryption key. You can download NOOK Study from <a href="https://yuzu.com/nsdownload">https://yuzu.com/nsdownload</a>.</p>
+<p>Once downloaded, install the application, register with your Barnes & Noble or nook account, and download at least one DRMed ebook through NOOK Study. It will be saved somewhere in a folder called "My Barnes & Noble eBooks" in your Documents folder.</p>
+<p>Now import that book into calibre. The log file and the key in the log should be automatically found by the plugin and used to decrypt the book.</p>
+<p>If the automatic process doesn't work for you, you can still find extract it manually and save it as a .b64 file for import into the plugin's preferences as follows:</p>
+<ol><li>In NOOK Study, select Settings/About (Windows) or NOOK Study/About NOOK Study (Mac) and in the dialog that appears click the link at the bottom to copy the log into the clipboard.</li>
+<li>Paste the copied log into a text editor</li>
+<li>Search for the text CCHashResponseV1</li>
+<li>On the line below which starts with ccHash, copy the text between the " marks after ccHash, but don't include the " marks.</li>
+<li>Save that text in a new <b>plain text</b> file, with file name extension .b64 (for example, key.b64)</li>
+<li>Import that file into the preferences through this dialog, using the "Import Existing Key Files" button.</li>
+</ol>
+
+
+<h3>Old instructions: Creating New Keys:</h3>
 
 <p>On the right-hand side of the plugin’s customization dialog, you will see a button with an icon that looks like a green plus sign (+). Clicking this button will open a new dialog for entering the necessary data to generate a new key.</p>
 <ul>
@@ -48,7 +65,7 @@ li {margin-top: 0.5em}
 
 <h3>Importing Existing Keyfiles:</h3>
 
-<p>At the bottom-left of the plugin’s customization dialog, you will see a button labeled "Import Existing Keyfiles". Use this button to import existing ‘.b64’ key files. Key files might come from being exported from this or older plugins, or may have been generated using the original i♥cabbages script.</p>
+<p>At the bottom-left of the plugin’s customization dialog, you will see a button labeled "Import Existing Keyfiles". Use this button to import existing ‘.b64’ key files. Key files might come from being exported from this or older plugins, or may have been generated using the original i♥cabbages script, or you may have made it by following the instructions above.</p>
 
 <p>Once done creating/deleting/renaming/importing decryption keys, click Close to exit the customization dialogue. Your changes wil only be saved permanently when you click OK in the main configuration dialog.</p>
 

DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/lib/DeDRM_Help.htm

@@ -17,7 +17,7 @@ p {margin-top: 0}
 
 <body>
 
-<h1>DeDRM Plugin <span class="version">(v6.0.9)</span></h1>
+<h1>DeDRM Plugin <span class="version">(v6.1.0)</span></h1>
 
 <p>This plugin removes DRM from ebooks when they are imported into calibre. If you already have DRMed ebooks in your calibre library, you will need to remove them and import them again.</p>
 

DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/lib/__init__.py

@@ -36,13 +36,16 @@ __docformat__ = 'restructuredtext en'
 #   6.0.7 - Error handling for incomplete PDF metadata
 #   6.0.8 - Fixes a Wine key issue and topaz support
 #   6.0.9 - Ported to work with newer versions of Calibre (moved to Qt5). Still supports older Qt4 versions.
+#   6.1.0 - Fixed multiple books import problem and PDF import with no key problem
+#   6.2.0 - Support for getting B&N key from nook Study log. Fix for UTF-8 filenames in Adobe ePubs.
+#           Fix for not copying needed files. Fix for getting default Adobe key for PDFs
 
 """
 Decrypt DRMed ebooks.
 """
 
 PLUGIN_NAME = u"DeDRM"
-PLUGIN_VERSION_TUPLE = (6, 0, 9)
+PLUGIN_VERSION_TUPLE = (6, 2, 0)
 PLUGIN_VERSION = u".".join([unicode(str(x)) for x in PLUGIN_VERSION_TUPLE])
 # Include an html helpfile in the plugin's zipfile with the following name.
 RESOURCE_NAME = PLUGIN_NAME + '_Help.htm'
@@ -90,30 +93,20 @@ class DeDRM(FileTypePlugin):
     on_import               = True
     priority                = 600
 
-    def initialize(self):
-        # convert old preferences, if necessary.
-        try:
-            from calibre_plugins.dedrm.prefs import convertprefs
-            convertprefs()
-        except:
-            traceback.print_exc()
 
+    def initialize(self):
         """
-        Dynamic modules can't be imported/loaded from a zipfile... so this routine
-        runs whenever the plugin gets initialized. This will extract the appropriate
+        Dynamic modules can't be imported/loaded from a zipfile.
+        So this routine will extract the appropriate
         library for the target OS and copy it to the 'alfcrypto' subdirectory of
         calibre's configuration directory. That 'alfcrypto' directory is then
         inserted into the syspath (as the very first entry) in the run function
         so the CDLL stuff will work in the alfcrypto.py script.
+
+        The extraction only happens once per version of the plugin
+        Also perform upgrade of preferences once per version
         """
         try:
-            if iswindows:
-                names = [u"alfcrypto.dll",u"alfcrypto64.dll"]
-            elif isosx:
-                names = [u"libalfcrypto.dylib"]
-            else:
-                names = [u"libalfcrypto32.so",u"libalfcrypto64.so",u"kindlekey.py",u"adobekey.py",u"subasyncio.py"]
-            lib_dict = self.load_resources(names)
             self.pluginsdir = os.path.join(config_dir,u"plugins")
             if not os.path.exists(self.pluginsdir):
                 os.mkdir(self.pluginsdir)
@@ -126,9 +119,38 @@ class DeDRM(FileTypePlugin):
             self.alfdir = os.path.join(self.maindir,u"libraryfiles")
             if not os.path.exists(self.alfdir):
                 os.mkdir(self.alfdir)
-            for entry, data in lib_dict.items():
-                file_path = os.path.join(self.alfdir, entry)
-                open(file_path,'wb').write(data)
+            # only continue if we've never run this version of the plugin before
+            self.verdir = os.path.join(self.maindir,PLUGIN_VERSION)
+            if not os.path.exists(self.verdir):
+                if iswindows:
+                    names = [u"alfcrypto.dll",u"alfcrypto64.dll"]
+                elif isosx:
+                    names = [u"libalfcrypto.dylib"]
+                else:
+                    names = [u"libalfcrypto32.so",u"libalfcrypto64.so",u"kindlekey.py",u"adobekey.py",u"subasyncio.py"]
+                lib_dict = self.load_resources(names)
+                print u"{0} v{1}: Copying needed library files from plugin's zip".format(PLUGIN_NAME, PLUGIN_VERSION)
+
+                for entry, data in lib_dict.items():
+                    file_path = os.path.join(self.alfdir, entry)
+                    try:
+                        os.remove(file_path)
+                    except:
+                        pass
+
+                    try:
+                        open(file_path,'wb').write(data)
+                    except:
+                        print u"{0} v{1}: Exception when copying needed library files after {2:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION, time.time()-self.starttime)
+                        traceback.print_exc()
+                        pass
+
+                # convert old preferences, if necessary.
+                from calibre_plugins.dedrm.prefs import convertprefs
+                convertprefs()
+
+                # mark that this version has been initialized
+                os.mkdir(self.verdir)
         except Exception, e:
             traceback.print_exc()
             raise
@@ -166,7 +188,12 @@ class DeDRM(FileTypePlugin):
                 of = self.temporary_file(u".epub")
 
                 # Give the user key, ebook and TemporaryPersistent file to the decryption function.
-                result = ignobleepub.decryptBook(userkey, inf.name, of.name)
+                try:
+                    result = ignobleepub.decryptBook(userkey, inf.name, of.name)
+                except:
+                    print u"{0} v{1}: Exception when trying to decrypt after {2:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION, time.time()-self.starttime)
+                    traceback.print_exc()
+                    result = 1
 
                 of.close()
 
@@ -177,8 +204,69 @@ class DeDRM(FileTypePlugin):
 
                 print u"{0} v{1}: Failed to decrypt with key {2:s} after {3:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION,keyname_masked,time.time()-self.starttime)
 
+            # perhaps we should see if we can get a key from a log file
+            print u"{0} v{1}: Looking for new NOOK Study Keys after {2:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION, time.time()-self.starttime)
+
+            # get the default NOOK Study keys
+            defaultkeys = []
+
+            try:
+                if iswindows or isosx:
+                    from calibre_plugins.dedrm.ignoblekey import nookkeys
+
+                    defaultkeys = nookkeys()
+                else: # linux
+                    from wineutils import WineGetKeys
+
+                    scriptpath = os.path.join(self.alfdir,u"ignoblekey.py")
+                    defaultkeys = WineGetKeys(scriptpath, u".b64",dedrmprefs['adobewineprefix'])
+
+            except:
+                print u"{0} v{1}: Exception when getting default NOOK Study Key after {2:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION, time.time()-self.starttime)
+                traceback.print_exc()
+
+            newkeys = []
+            for keyvalue in defaultkeys:
+                if keyvalue not in dedrmprefs['bandnkeys'].values():
+                    newkeys.append(keyvalue)
+
+            if len(newkeys) > 0:
+                try:
+                    for i,userkey in enumerate(newkeys):
+                        print u"{0} v{1}: Trying a new default key".format(PLUGIN_NAME, PLUGIN_VERSION)
+
+                        of = self.temporary_file(u".epub")
+
+                        # Give the user key, ebook and TemporaryPersistent file to the decryption function.
+                        try:
+                            result = ignobleepub.decryptBook(userkey, inf.name, of.name)
+                        except:
+                           print u"{0} v{1}: Exception when trying to decrypt after {2:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION, time.time()-self.starttime)
+                           traceback.print_exc()
+                           result = 1
+
+                        of.close()
+
+                        if result == 0:
+                            # Decryption was a success
+                            # Store the new successful key in the defaults
+                            print u"{0} v{1}: Saving a new default key".format(PLUGIN_NAME, PLUGIN_VERSION)
+                            try:
+                                dedrmprefs.addnamedvaluetoprefs('bandnkeys','default_key',keyvalue)
+                                dedrmprefs.writeprefs()
+                                print u"{0} v{1}: Saved a new default key after {2:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION,time.time()-self.starttime)
+                            except:
+                                print u"{0} v{1}: Exception saving a new default key after {2:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION, time.time()-self.starttime)
+                                traceback.print_exc()
+                            # Return the modified PersistentTemporary file to calibre.
+                            return of.name
+
+                        print u"{0} v{1}: Failed to decrypt with new default key after {2:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION,time.time()-self.starttime)
+                except Exception, e:
+                    pass
+
             print u"{0} v{1}: Ultimately failed to decrypt after {2:.1f} seconds.\nRead the FAQs at Alf's blog: http://apprenticealf.wordpress.com/".format(PLUGIN_NAME, PLUGIN_VERSION,time.time()-self.starttime)
-            raise DeDRMError(u"{0} v{1}: Ultimately failed to decrypt “{2}” after {3:.1f} seconds.\nRead the FAQs at Alf's blog: http://apprenticealf.wordpress.com/".format(PLUGIN_NAME, PLUGIN_VERSION, os.path.basename(path_to_ebook),time.time()-self.starttime))
+            raise DeDRMError(u"{0} v{1}: Ultimately failed to decrypt after {2:.1f} seconds.".format(PLUGIN_NAME, PLUGIN_VERSION, time.time()-self.starttime))
 
         # import the Adobe Adept ePub handler
         import calibre_plugins.dedrm.ineptepub as ineptepub
@@ -196,6 +284,8 @@ class DeDRM(FileTypePlugin):
                 try:
                     result = ineptepub.decryptBook(userkey, inf.name, of.name)
                 except:
+                    print u"{0} v{1}: Exception when decrypting after {2:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION, time.time()-self.starttime)
+                    traceback.print_exc()
                     result = 1
 
                 of.close()
@@ -226,6 +316,7 @@ class DeDRM(FileTypePlugin):
 
                 self.default_key = defaultkeys[0]
             except:
+                print u"{0} v{1}: Exception when getting default Adobe Key after {2:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION, time.time()-self.starttime)
                 traceback.print_exc()
                 self.default_key = u""
 
@@ -244,6 +335,8 @@ class DeDRM(FileTypePlugin):
                         try:
                             result = ineptepub.decryptBook(userkey, inf.name, of.name)
                         except:
+                            print u"{0} v{1}: Exception when decrypting after {2:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION, time.time()-self.starttime)
+                            traceback.print_exc()
                             result = 1
 
                         of.close()
@@ -255,7 +348,9 @@ class DeDRM(FileTypePlugin):
                             try:
                                 dedrmprefs.addnamedvaluetoprefs('adeptkeys','default_key',keyvalue.encode('hex'))
                                 dedrmprefs.writeprefs()
+                                print u"{0} v{1}: Saved a new default key after {2:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION,time.time()-self.starttime)
                             except:
+                                print u"{0} v{1}: Exception when saving a new default key after {2:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION, time.time()-self.starttime)
                                 traceback.print_exc()
                             # Return the modified PersistentTemporary file to calibre.
                             return of.name
@@ -266,12 +361,12 @@ class DeDRM(FileTypePlugin):
 
             # Something went wrong with decryption.
             print u"{0} v{1}: Ultimately failed to decrypt after {2:.1f} seconds.\nRead the FAQs at Alf's blog: http://apprenticealf.wordpress.com/".format(PLUGIN_NAME, PLUGIN_VERSION,time.time()-self.starttime)
-            raise DeDRMError(u"{0} v{1}: Ultimately failed to decrypt “{2}” after {3:.1f} seconds.\nRead the FAQs at Alf's blog: http://apprenticealf.wordpress.com/".format(PLUGIN_NAME, PLUGIN_VERSION, os.path.basename(path_to_ebook),time.time()-self.starttime))
+            raise DeDRMError(u"{0} v{1}: Ultimately failed to decrypt after {2:.1f} seconds.".format(PLUGIN_NAME, PLUGIN_VERSION,time.time()-self.starttime))
 
         # Not a Barnes & Noble nor an Adobe Adept
         # Import the fixed epub.
         print u"{0} v{1}: “{2}” is neither an Adobe Adept nor a Barnes & Noble encrypted ePub".format(PLUGIN_NAME, PLUGIN_VERSION, os.path.basename(path_to_ebook))
-        return inf.name
+        raise DeDRMError(u"{0} v{1}: Couldn't decrypt after {2:.1f} seconds. DRM free perhaps?".format(PLUGIN_NAME, PLUGIN_VERSION,time.time()-self.starttime))
 
     def PDFDecrypt(self,path_to_ebook):
         import calibre_plugins.dedrm.prefs as prefs
@@ -289,6 +384,8 @@ class DeDRM(FileTypePlugin):
             try:
                 result = ineptpdf.decryptBook(userkey, path_to_ebook, of.name)
             except:
+                print u"{0} v{1}: Exception when decrypting after {2:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION, time.time()-self.starttime)
+                traceback.print_exc()
                 result = 1
 
             of.close()
@@ -298,67 +395,73 @@ class DeDRM(FileTypePlugin):
                 # Return the modified PersistentTemporary file to calibre.
                 return of.name
 
-            # perhaps we need to get a new default ADE key
-            print u"{0} v{1}: Looking for new default Adobe Digital Editions Keys after {2:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION, time.time()-self.starttime)
+            print u"{0} v{1}: Failed to decrypt with key {2:s} after {3:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION,keyname,time.time()-self.starttime)
 
-            # get the default Adobe keys
-            defaultkeys = []
+        # perhaps we need to get a new default ADE key
+        print u"{0} v{1}: Looking for new default Adobe Digital Editions Keys after {2:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION, time.time()-self.starttime)
 
+        # get the default Adobe keys
+        defaultkeys = []
+
+        try:
             if iswindows or isosx:
-                import calibre_plugins.dedrm.adobekey as adobe
+                from calibre_plugins.dedrm.adobekey import adeptkeys
 
-                try:
-                    defaultkeys = adobe.adeptkeys()
-                except:
-                    pass
-            else:
-                # linux
-                try:
-                    from wineutils import WineGetKeys
+                defaultkeys = adeptkeys()
+            else: # linux
+                from wineutils import WineGetKeys
 
-                    scriptpath = os.path.join(self.alfdir,u"adobekey.py")
-                    defaultkeys = WineGetKeys(scriptpath, u".der",dedrmprefs['adobewineprefix'])
-                except:
-                    pass
+                scriptpath = os.path.join(self.alfdir,u"adobekey.py")
+                defaultkeys = WineGetKeys(scriptpath, u".der",dedrmprefs['adobewineprefix'])
 
-            newkeys = []
-            for keyvalue in defaultkeys:
-                if keyvalue.encode('hex') not in dedrmprefs['adeptkeys'].values():
-                    newkeys.append(keyvalue)
+            self.default_key = defaultkeys[0]
+        except:
+            print u"{0} v{1}: Exception when getting default Adobe Key after {2:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION, time.time()-self.starttime)
+            traceback.print_exc()
+            self.default_key = u""
 
-            if len(newkeys) > 0:
-                try:
-                    for i,userkey in enumerate(newkeys):
-                        print u"{0} v{1}: Trying a new default key".format(PLUGIN_NAME, PLUGIN_VERSION)
-                        of = self.temporary_file(u".pdf")
+        newkeys = []
+        for keyvalue in defaultkeys:
+            if keyvalue.encode('hex') not in dedrmprefs['adeptkeys'].values():
+                newkeys.append(keyvalue)
 
-                        # Give the user key, ebook and TemporaryPersistent file to the decryption function.
+        if len(newkeys) > 0:
+            try:
+                for i,userkey in enumerate(newkeys):
+                    print u"{0} v{1}: Trying a new default key".format(PLUGIN_NAME, PLUGIN_VERSION)
+                    of = self.temporary_file(u".pdf")
+
+                    # Give the user key, ebook and TemporaryPersistent file to the decryption function.
+                    try:
+                        result = ineptpdf.decryptBook(userkey, path_to_ebook, of.name)
+                    except:
+                        print u"{0} v{1}: Exception when decrypting after {2:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION, time.time()-self.starttime)
+                        traceback.print_exc()
+                        result = 1
+
+                    of.close()
+
+                    if  result == 0:
+                        # Decryption was a success
+                        # Store the new successful key in the defaults
+                        print u"{0} v{1}: Saving a new default key".format(PLUGIN_NAME, PLUGIN_VERSION)
                         try:
-                            result = ineptepdf.decryptBook(userkey, inf.name, of.name)
+                            dedrmprefs.addnamedvaluetoprefs('adeptkeys','default_key',keyvalue.encode('hex'))
+                            dedrmprefs.writeprefs()
+                            print u"{0} v{1}: Saved a new default key after {2:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION,time.time()-self.starttime)
                         except:
-                            result = 1
+                            print u"{0} v{1}: Exception when saving a new default key after {2:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION, time.time()-self.starttime)
+                            traceback.print_exc()
+                        # Return the modified PersistentTemporary file to calibre.
+                        return of.name
 
-                        of.close()
-
-                        if  result == 0:
-                            # Decryption was a success
-                            # Store the new successful key in the defaults
-                            print u"{0} v{1}: Saving a new default key".format(PLUGIN_NAME, PLUGIN_VERSION)
-                            try:
-                                dedrmprefs.addnamedvaluetoprefs('adeptkeys','default_key',keyvalue.encode('hex'))
-                                dedrmprefs.writeprefs()
-                            except:
-                                traceback.print_exc()
-                            # Return the modified PersistentTemporary file to calibre.
-                            return of.name
-
-                        print u"{0} v{1}: Failed to decrypt with new default key after {2:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION,time.time()-self.starttime)
-                except Exception, e:
-                    pass
+                    print u"{0} v{1}: Failed to decrypt with new default key after {2:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION,time.time()-self.starttime)
+            except Exception, e:
+                pass
 
         # Something went wrong with decryption.
         print u"{0} v{1}: Ultimately failed to decrypt after {2:.1f} seconds.\nRead the FAQs at Alf's blog: http://apprenticealf.wordpress.com/".format(PLUGIN_NAME, PLUGIN_VERSION,time.time()-self.starttime)
-        raise DeDRMError(u"{0} v{1}: Ultimately failed to decrypt “{2}” after {3:.1f} seconds.\nRead the FAQs at Alf's blog: http://apprenticealf.wordpress.com/".format(PLUGIN_NAME, PLUGIN_VERSION, os.path.basename(path_to_ebook),time.time()-self.starttime))
+        raise DeDRMError(u"{0} v{1}: Ultimately failed to decrypt after {2:.1f} seconds.".format(PLUGIN_NAME, PLUGIN_VERSION, time.time()-self.starttime))
 
 
     def KindleMobiDecrypt(self,path_to_ebook):
@@ -397,6 +500,8 @@ class DeDRM(FileTypePlugin):
                     scriptpath = os.path.join(self.alfdir,u"kindlekey.py")
                     defaultkeys = WineGetKeys(scriptpath, u".k4i",dedrmprefs['kindlewineprefix'])
             except:
+                print u"{0} v{1}: Exception when getting default Kindle Key after {2:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION, time.time()-self.starttime)
+                traceback.print_exc()
                 pass
 
             newkeys = {}
@@ -419,8 +524,7 @@ class DeDRM(FileTypePlugin):
             if not decoded:
                 #if you reached here then no luck raise and exception
                 print u"{0} v{1}: Ultimately failed to decrypt after {2:.1f} seconds.\nRead the FAQs at Alf's blog: http://apprenticealf.wordpress.com/".format(PLUGIN_NAME, PLUGIN_VERSION,time.time()-self.starttime)
-                traceback.print_exc()
-                raise DeDRMError(u"{0} v{1}: Ultimately failed to decrypt “{4}” after {3:.1f} seconds with error: {2}\nRead the FAQs at Alf's blog: http://apprenticealf.wordpress.com/".format(PLUGIN_NAME, PLUGIN_VERSION, e.args[0],time.time()-self.starttime,os.path.basename(path_to_ebook)))
+                raise DeDRMError(u"{0} v{1}: Ultimately failed to decrypt after {2:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION,time.time()-self.starttime))
 
         of = self.temporary_file(book.getBookExtension())
         book.getFile(of.name)
@@ -454,7 +558,7 @@ class DeDRM(FileTypePlugin):
             print u"{0} v{1}: Failed to decrypt with key {2:s} after {3:.1f} seconds".format(PLUGIN_NAME, PLUGIN_VERSION,keyname_masked,time.time()-self.starttime)
 
         print u"{0} v{1}: Ultimately failed to decrypt after {2:.1f} seconds.\nRead the FAQs at Alf's blog: http://apprenticealf.wordpress.com/".format(PLUGIN_NAME, PLUGIN_VERSION,time.time()-self.starttime)
-        raise DeDRMError(u"{0} v{1}: Ultimately failed to decrypt “{2}” after {3:.1f} seconds.\nRead the FAQs at Alf's blog: http://apprenticealf.wordpress.com/".format(PLUGIN_NAME, PLUGIN_VERSION, os.path.basename(path_to_ebook),time.time()-self.starttime))
+        raise DeDRMError(u"{0} v{1}: Ultimately failed to decrypt after {2:.1f} seconds.".format(PLUGIN_NAME, PLUGIN_VERSION, time.time()-self.starttime))
 
 
     def run(self, path_to_ebook):

DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/lib/android.py

@@ -10,6 +10,7 @@ from cStringIO import StringIO
 from binascii import a2b_hex, b2a_hex
 
 STORAGE = 'AmazonSecureStorage.xml'
+STORAGE2 = 'map_data_storage.db'
 
 class AndroidObfuscation(object):
     '''AndroidObfuscation
@@ -76,13 +77,8 @@ def parse_preference(path):
 
 def get_serials(path=None):
     ''' get serials from android's shared preference xml '''
-    if path is None:
-        if not os.path.isfile(STORAGE):
-            if os.path.isfile("backup.ab"):
-                get_storage()
-            else:
-                return []
-        path = STORAGE
+    if path is None and os.path.isfile("backup.ab"):
+        return get_storage()
 
     if not os.path.isfile(path):
         return []
@@ -113,16 +109,27 @@ def get_serials(path=None):
     try:
         tokens = set(get_value('kindle.account.tokens').split(','))
     except:
-        return [dsnid]
+        return []
 
     serials = []
     for token in tokens:
         if token:
             serials.append('%s%s' % (dsnid, token))
-    serials.append(dsnid)
-    for token in tokens:
-        if token:
-            serials.append(token)
+    return serials
+
+def get_serials2(path=STORAGE2):
+    import sqlite3
+    connection = sqlite3.connect(path)
+    cursor = connection.cursor()
+    cursor.execute('''select userdata_value from userdata where userdata_key like '%/%token.device.deviceserialname%' ''')
+    dsns = [x[0].encode('utf8') for x in cursor.fetchall()]
+
+    cursor.execute('''select userdata_value from userdata where userdata_key like '%/%kindle.account.tokens%' ''')
+    tokens = [x[0].encode('utf8') for x in cursor.fetchall()]
+    serials = []
+    for x in dsns:
+        for y in tokens:
+            serials.append('%s%s' % (x, y))
     return serials
 
 def get_storage(path='backup.ab'):
@@ -130,25 +137,38 @@ def get_storage(path='backup.ab'):
     backup.ab can be get using adb command:
     shell> adb backup com.amazon.kindle
     '''
+    if not os.path.isfile(path):
+        serials = []
+        if os.path.isfile(STORAGE2):
+            serials.extend(get_serials2(STORAGE2))
+        if os.path.isfile(STORAGE):
+            serials.extend(get_serials(STORAGE))
+        return serials
     output = None
     read = open(path, 'rb')
     head = read.read(24)
-    if head == 'ANDROID BACKUP\n1\n1\nnone\n':
+    if head[:14] == 'ANDROID BACKUP':
         output = StringIO(zlib.decompress(read.read()))
     read.close()
 
     if not output:
-        return False
+        return []
 
+    serials = []
     tar = tarfile.open(fileobj=output)
     for member in tar.getmembers():
-        if member.name.strip().endswith(STORAGE):
+        if member.name.strip().endswith(STORAGE2):
+            write = open(STORAGE2, 'w')
+            write.write(tar.extractfile(member).read())
+            write.close()
+            serials.extend(get_serials2(STORAGE2))
+        elif member.name.strip().endswith(STORAGE):
             write = open(STORAGE, 'w')
             write.write(tar.extractfile(member).read())
             write.close()
-            break
+            serials.extend(get_serials(STORAGE))
 
-    return True
+    return serials
 
 __all__ = [ 'get_storage', 'get_serials', 'parse_preference',
             'AndroidObfuscation', 'AndroidObfuscationV2', 'STORAGE']

DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/lib/android_readme.txt

@@ -1,6 +1,7 @@
 1.1 get AmazonSecureStorage.xml from /data/data/com.amazon.kindle/shared_prefs/AmazonSecureStorage.xml
+    or map_data_storage.db from /data/data/com.amazon.kindle/databases/map_data_storage.db
 
 1.2 on android 4.0+, run `adb backup com.amazon.kindle` from PC will get backup.ab
-    now android.py can convert backup.ab to AmazonSecureStorage.xml
+    now android.py can convert backup.ab to AmazonSecureStorage.xml and map_data_storage.db
 
-2. run `k4mobidedrm.py -a AmazonSecureStorage.xml <infile> <outdir>'
+2. run `k4mobidedrm.py <infile> <outdir>'

DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/lib/ignoblekey.py

@@ -0,0 +1,335 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from __future__ import with_statement
+
+# ignoblekey.py
+# Copyright © 2015 Apprentice Alf
+
+# Based on kindlekey.py, Copyright © 2010-2013 by some_updates and Apprentice Alf
+
+# Released under the terms of the GNU General Public Licence, version 3
+# <http://www.gnu.org/licenses/>
+
+# Revision history:
+#   1.0 - Initial release
+
+"""
+Get Barnes & Noble EPUB user key from nook Studio log file
+"""
+
+__license__ = 'GPL v3'
+__version__ = "1.0"
+
+import sys
+import os
+import hashlib
+import getopt
+import re
+
+# Wrap a stream so that output gets flushed immediately
+# and also make sure that any unicode strings get
+# encoded using "replace" before writing them.
+class SafeUnbuffered:
+    def __init__(self, stream):
+        self.stream = stream
+        self.encoding = stream.encoding
+        if self.encoding == None:
+            self.encoding = "utf-8"
+    def write(self, data):
+        if isinstance(data,unicode):
+            data = data.encode(self.encoding,"replace")
+        self.stream.write(data)
+        self.stream.flush()
+    def __getattr__(self, attr):
+        return getattr(self.stream, attr)
+
+try:
+    from calibre.constants import iswindows, isosx
+except:
+    iswindows = sys.platform.startswith('win')
+    isosx = sys.platform.startswith('darwin')
+
+def unicode_argv():
+    if iswindows:
+        # Uses shell32.GetCommandLineArgvW to get sys.argv as a list of Unicode
+        # strings.
+
+        # Versions 2.x of Python don't support Unicode in sys.argv on
+        # Windows, with the underlying Windows API instead replacing multi-byte
+        # characters with '?'.  So use shell32.GetCommandLineArgvW to get sys.argv
+        # as a list of Unicode strings and encode them as utf-8
+
+        from ctypes import POINTER, byref, cdll, c_int, windll
+        from ctypes.wintypes import LPCWSTR, LPWSTR
+
+        GetCommandLineW = cdll.kernel32.GetCommandLineW
+        GetCommandLineW.argtypes = []
+        GetCommandLineW.restype = LPCWSTR
+
+        CommandLineToArgvW = windll.shell32.CommandLineToArgvW
+        CommandLineToArgvW.argtypes = [LPCWSTR, POINTER(c_int)]
+        CommandLineToArgvW.restype = POINTER(LPWSTR)
+
+        cmd = GetCommandLineW()
+        argc = c_int(0)
+        argv = CommandLineToArgvW(cmd, byref(argc))
+        if argc.value > 0:
+            # Remove Python executable and commands if present
+            start = argc.value - len(sys.argv)
+            return [argv[i] for i in
+                    xrange(start, argc.value)]
+        # if we don't have any arguments at all, just pass back script name
+        # this should never happen
+        return [u"ignoblekey.py"]
+    else:
+        argvencoding = sys.stdin.encoding
+        if argvencoding == None:
+            argvencoding = "utf-8"
+        return [arg if (type(arg) == unicode) else unicode(arg,argvencoding) for arg in sys.argv]
+
+class DrmException(Exception):
+    pass
+
+# Locate all of the nookStudy/nook for PC/Mac log file and return as list
+def getNookLogFiles():
+    logFiles = []
+    found = False
+    if iswindows:
+        import _winreg as winreg
+
+        # some 64 bit machines do not have the proper registry key for some reason
+        # or the python interface to the 32 vs 64 bit registry is broken
+        paths = set()
+        if 'LOCALAPPDATA' in os.environ.keys():
+            # Python 2.x does not return unicode env. Use Python 3.x
+            path = winreg.ExpandEnvironmentStrings(u"%LOCALAPPDATA%")
+            if os.path.isdir(path):
+                paths.add(path)
+        if 'USERPROFILE' in os.environ.keys():
+            # Python 2.x does not return unicode env. Use Python 3.x
+            path = winreg.ExpandEnvironmentStrings(u"%USERPROFILE%")+u"\\AppData\\Local"
+            if os.path.isdir(path):
+                paths.add(path)
+            path = winreg.ExpandEnvironmentStrings(u"%USERPROFILE%")+u"\\AppData\\Roaming"
+            if os.path.isdir(path):
+                paths.add(path)
+        # User Shell Folders show take precedent over Shell Folders if present
+        try:
+            regkey = winreg.OpenKey(winreg.HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders\\")
+            path = winreg.QueryValueEx(regkey, 'Local AppData')[0]
+            if os.path.isdir(path):
+                paths.add(path)
+        except WindowsError:
+            pass
+        try:
+            regkey = winreg.OpenKey(winreg.HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\User Shell Folders\\")
+            path = winreg.QueryValueEx(regkey, 'AppData')[0]
+            if os.path.isdir(path):
+                paths.add(path)
+        except WindowsError:
+            pass
+        try:
+            regkey = winreg.OpenKey(winreg.HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders\\")
+            path = winreg.QueryValueEx(regkey, 'Local AppData')[0]
+            if os.path.isdir(path):
+                paths.add(path)
+        except WindowsError:
+            pass
+        try:
+            regkey = winreg.OpenKey(winreg.HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders\\")
+            path = winreg.QueryValueEx(regkey, 'AppData')[0]
+            if os.path.isdir(path):
+                paths.add(path)
+        except WindowsError:
+            pass
+ 
+        for path in paths:
+            # look for nookStudy log file
+            logpath = path +'\\Barnes & Noble\\NOOKstudy\\logs\\BNClientLog.txt'
+            if os.path.isfile(logpath):
+                found = True
+                print('Found nookStudy log file: ' + logpath.encode('ascii','ignore'))
+                logFiles.append(logpath)
+    else:
+        home = os.getenv('HOME')
+        # check for BNClientLog.txt in various locations
+        testpath = home + '/Library/Application Support/Barnes & Noble/DesktopReader/logs/BNClientLog.txt'
+        if os.path.isfile(testpath):
+            logFiles.append(testpath)
+            print('Found nookStudy log file: ' + testpath)
+            found = True
+        testpath = home + '/Library/Application Support/Barnes & Noble/DesktopReader/indices/BNClientLog.txt'
+        if os.path.isfile(testpath):
+            logFiles.append(testpath)
+            print('Found nookStudy log file: ' + testpath)
+            found = True
+        testpath = home + '/Library/Application Support/Barnes & Noble/BNDesktopReader/logs/BNClientLog.txt'
+        if os.path.isfile(testpath):
+            logFiles.append(testpath)
+            print('Found nookStudy log file: ' + testpath)
+            found = True
+        testpath = home + '/Library/Application Support/Barnes & Noble/BNDesktopReader/indices/BNClientLog.txt'
+        if os.path.isfile(testpath):
+            logFiles.append(testpath)
+            print('Found nookStudy log file: ' + testpath)
+            found = True
+
+    if not found:
+        print('No nook Study log files have been found.')
+    return logFiles
+
+
+# Extract CCHash key(s) from log file
+def getKeysFromLog(kLogFile):
+    keys = []
+    regex = re.compile("ccHash: \"(.{28})\"");
+    for line in open(kLogFile):
+        for m in regex.findall(line):
+            keys.append(m)
+    return keys
+
+# interface for calibre plugin
+def nookkeys(files = []):
+    keys = []
+    if files == []:
+        files = getNookLogFiles()
+    for file in files:
+        fileKeys = getKeysFromLog(file)
+        if fileKeys:
+            print u"Found {0} keys in the Nook Study log files".format(len(fileKeys))
+            keys.extend(fileKeys)
+    return keys
+
+# interface for Python DeDRM
+# returns single key or multiple keys, depending on path or file passed in
+def getkey(outpath, files=[]):
+    keys = nookkeys(files)
+    if len(keys) > 0:
+        if not os.path.isdir(outpath):
+            outfile = outpath
+            with file(outfile, 'w') as keyfileout:
+                keyfileout.write(keys[0])
+            print u"Saved a key to {0}".format(outfile)
+        else:
+            keycount = 0
+            for key in keys:
+                while True:
+                    keycount += 1
+                    outfile = os.path.join(outpath,u"nookkey{0:d}.b64".format(keycount))
+                    if not os.path.exists(outfile):
+                        break
+                with file(outfile, 'w') as keyfileout:
+                    keyfileout.write(key)
+                print u"Saved a key to {0}".format(outfile)
+        return True
+    return False
+
+def usage(progname):
+    print u"Finds the nook Study encryption keys."
+    print u"Keys are saved to the current directory, or a specified output directory."
+    print u"If a file name is passed instead of a directory, only the first key is saved, in that file."
+    print u"Usage:"
+    print u"    {0:s} [-h] [-k <logFile>] [<outpath>]".format(progname)
+
+
+def cli_main():
+    sys.stdout=SafeUnbuffered(sys.stdout)
+    sys.stderr=SafeUnbuffered(sys.stderr)
+    argv=unicode_argv()
+    progname = os.path.basename(argv[0])
+    print u"{0} v{1}\nCopyright © 2015 Apprentice Alf".format(progname,__version__)
+
+    try:
+        opts, args = getopt.getopt(argv[1:], "hk:")
+    except getopt.GetoptError, err:
+        print u"Error in options or arguments: {0}".format(err.args[0])
+        usage(progname)
+        sys.exit(2)
+
+    files = []
+    for o, a in opts:
+        if o == "-h":
+            usage(progname)
+            sys.exit(0)
+        if o == "-k":
+            files = [a]
+
+    if len(args) > 1:
+        usage(progname)
+        sys.exit(2)
+
+    if len(args) == 1:
+        # save to the specified file or directory
+        outpath = args[0]
+        if not os.path.isabs(outpath):
+           outpath = os.path.abspath(outpath)
+    else:
+        # save to the same directory as the script
+        outpath = os.path.dirname(argv[0])
+
+    # make sure the outpath is the
+    outpath = os.path.realpath(os.path.normpath(outpath))
+
+    if not getkey(outpath, files):
+        print u"Could not retrieve nook Study key."
+    return 0
+
+
+def gui_main():
+    try:
+        import Tkinter
+        import Tkconstants
+        import tkMessageBox
+        import traceback
+    except:
+        return cli_main()
+
+    class ExceptionDialog(Tkinter.Frame):
+        def __init__(self, root, text):
+            Tkinter.Frame.__init__(self, root, border=5)
+            label = Tkinter.Label(self, text=u"Unexpected error:",
+                                  anchor=Tkconstants.W, justify=Tkconstants.LEFT)
+            label.pack(fill=Tkconstants.X, expand=0)
+            self.text = Tkinter.Text(self)
+            self.text.pack(fill=Tkconstants.BOTH, expand=1)
+
+            self.text.insert(Tkconstants.END, text)
+
+
+    argv=unicode_argv()
+    root = Tkinter.Tk()
+    root.withdraw()
+    progpath, progname = os.path.split(argv[0])
+    success = False
+    try:
+        keys = nookkeys()
+        keycount = 0
+        for key in keys:
+            print key
+            while True:
+                keycount += 1
+                outfile = os.path.join(progpath,u"nookkey{0:d}.b64".format(keycount))
+                if not os.path.exists(outfile):
+                    break
+
+            with file(outfile, 'w') as keyfileout:
+                keyfileout.write(key)
+            success = True
+            tkMessageBox.showinfo(progname, u"Key successfully retrieved to {0}".format(outfile))
+    except DrmException, e:
+        tkMessageBox.showerror(progname, u"Error: {0}".format(str(e)))
+    except Exception:
+        root.wm_state('normal')
+        root.title(progname)
+        text = traceback.format_exc()
+        ExceptionDialog(root, text).pack(fill=Tkconstants.BOTH, expand=1)
+        root.mainloop()
+    if not success:
+        return 1
+    return 0
+
+if __name__ == '__main__':
+    if len(sys.argv) > 1:
+        sys.exit(cli_main())
+    sys.exit(gui_main())

DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/lib/ineptepub.py

@@ -37,13 +37,14 @@ from __future__ import with_statement
 #   5.9 - Fixed to retain zip file metadata (e.g. file modification date)
 #   6.0 - moved unicode_argv call inside main for Windows DeDRM compatibility
 #   6.1 - Work if TkInter is missing
+#   6.2 - Handle UTF-8 file names inside an ePub, fix by Jose Luis
 
 """
 Decrypt Adobe Digital Editions encrypted ePub books.
 """
 
 __license__ = 'GPL v3'
-__version__ = "6.1"
+__version__ = "6.2"
 
 import sys
 import os
@@ -366,7 +367,7 @@ class Decryptor(object):
         return bytes
 
     def decrypt(self, path, data):
-        if path in self._encrypted:
+        if path.encode('utf-8') in self._encrypted:
             data = self._aes.decrypt(data)[16:]
             data = data[:-ord(data[-1])]
             data = self.decompress(data)

DeDRM_Windows_Application/DeDRM_App/DeDRM_lib/lib/subasyncio.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python
+# vim:ts=4:sw=4:softtabstop=4:smarttab:expandtab
+
+import os, sys
+import signal
+import threading
+import subprocess
+from subprocess import Popen, PIPE, STDOUT
+
+# **heavily** chopped up and modfied version of asyncproc.py
+# to make it actually work on Windows as well as Mac/Linux
+# For the original see:
+# "http://www.lysator.liu.se/~bellman/download/"
+# author is  "Thomas Bellman <bellman@lysator.liu.se>"
+# available under GPL version 3 or Later
+
+# create an asynchronous subprocess whose output can be collected in
+# a non-blocking manner
+
+# What a mess!  Have to use threads just to get non-blocking io
+# in a cross-platform manner
+
+# luckily all thread use is hidden within this class
+
+class Process(object):
+    def __init__(self, *params, **kwparams):
+        if len(params) <= 3:
+            kwparams.setdefault('stdin', subprocess.PIPE)
+        if len(params) <= 4:
+            kwparams.setdefault('stdout', subprocess.PIPE)
+        if len(params) <= 5:
+            kwparams.setdefault('stderr', subprocess.PIPE)
+        self.__pending_input = []
+        self.__collected_outdata = []
+        self.__collected_errdata = []
+        self.__exitstatus = None
+        self.__lock = threading.Lock()
+        self.__inputsem = threading.Semaphore(0)
+        self.__quit = False
+
+        self.__process = subprocess.Popen(*params, **kwparams)
+
+        if self.__process.stdin:
+            self.__stdin_thread = threading.Thread(
+                name="stdin-thread",
+                target=self.__feeder, args=(self.__pending_input,
+                                            self.__process.stdin))
+            self.__stdin_thread.setDaemon(True)
+            self.__stdin_thread.start()
+
+        if self.__process.stdout:
+            self.__stdout_thread = threading.Thread(
+                name="stdout-thread",
+                target=self.__reader, args=(self.__collected_outdata,
+                                            self.__process.stdout))
+            self.__stdout_thread.setDaemon(True)
+            self.__stdout_thread.start()
+
+        if self.__process.stderr:
+            self.__stderr_thread = threading.Thread(
+                name="stderr-thread",
+                target=self.__reader, args=(self.__collected_errdata,
+                                            self.__process.stderr))
+            self.__stderr_thread.setDaemon(True)
+            self.__stderr_thread.start()
+
+    def pid(self):
+        return self.__process.pid
+
+    def kill(self, signal):
+        self.__process.send_signal(signal)
+
+    # check on subprocess (pass in 'nowait') to act like poll
+    def wait(self, flag):
+        if flag.lower() == 'nowait':
+            rc = self.__process.poll()
+        else:
+            rc = self.__process.wait()
+        if rc != None:
+            if self.__process.stdin:
+                self.closeinput()
+            if self.__process.stdout:
+                self.__stdout_thread.join()
+            if self.__process.stderr:
+                self.__stderr_thread.join()
+        return self.__process.returncode
+
+    def terminate(self):
+        if self.__process.stdin:
+            self.closeinput()
+        self.__process.terminate()
+
+    # thread gets data from subprocess stdout
+    def __reader(self, collector, source):
+        while True:
+            data = os.read(source.fileno(), 65536)
+            self.__lock.acquire()
+            collector.append(data)
+            self.__lock.release()
+            if data == "":
+                source.close()
+                break
+        return
+
+    # thread feeds data to subprocess stdin
+    def __feeder(self, pending, drain):
+        while True:
+            self.__inputsem.acquire()
+            self.__lock.acquire()
+            if not pending  and self.__quit:
+                drain.close()
+                self.__lock.release()
+                break
+            data = pending.pop(0)
+            self.__lock.release()
+            drain.write(data)
+
+    # non-blocking read of data from subprocess stdout
+    def read(self):
+        self.__lock.acquire()
+        outdata = "".join(self.__collected_outdata)
+        del self.__collected_outdata[:]
+        self.__lock.release()
+        return outdata
+
+    # non-blocking read of data from subprocess stderr
+    def readerr(self):
+        self.__lock.acquire()
+        errdata = "".join(self.__collected_errdata)
+        del self.__collected_errdata[:]
+        self.__lock.release()
+        return errdata
+
+    # non-blocking write to stdin of subprocess
+    def write(self, data):
+        if self.__process.stdin is None:
+            raise ValueError("Writing to process with stdin not a pipe")
+        self.__lock.acquire()
+        self.__pending_input.append(data)
+        self.__inputsem.release()
+        self.__lock.release()
+
+    # close stdinput of subprocess
+    def closeinput(self):
+        self.__lock.acquire()
+        self.__quit = True
+        self.__inputsem.release()
+        self.__lock.release()