move from work dir
This commit is contained in:
Madison Scott-Clary
857
mitzvot/linux-installer.sh
Normal file
857
mitzvot/linux-installer.sh
Normal file
@ -0,0 +1,857 @@
|
||||
#!/bin/sh
|
||||
# linux-installer.sh
|
||||
# Copyright (C) 2018 Kovid Goyal <kovid at kovidgoyal.net>
|
||||
|
||||
search_for_python() {
|
||||
# We have to search for python as Ubuntu, in its infinite wisdom decided
|
||||
# to release 18.04 with no python symlink, making it impossible to run polyglot
|
||||
# python scripts.
|
||||
|
||||
# We cannot use command -v as it is not implemented in the posh shell shipped with
|
||||
# Ubuntu/Debian. Similarly, there is no guarantee that which is installed.
|
||||
# Shell scripting is a horrible joke, thank heavens for python.
|
||||
local IFS=:
|
||||
if [ $ZSH_VERSION ]; then
|
||||
# zsh does not split by default
|
||||
setopt sh_word_split
|
||||
fi
|
||||
local candidate_path
|
||||
local candidate_python
|
||||
local pythons=python3:python2
|
||||
# disable pathname expansion (globbing)
|
||||
set -f
|
||||
for candidate_path in $PATH
|
||||
do
|
||||
if [ ! -z $candidate_path ]
|
||||
then
|
||||
for candidate_python in $pythons
|
||||
do
|
||||
if [ ! -z "$candidate_path" ]
|
||||
then
|
||||
if [ -x "$candidate_path/$candidate_python" ]
|
||||
then
|
||||
printf "$candidate_path/$candidate_python"
|
||||
return
|
||||
fi
|
||||
fi
|
||||
done
|
||||
fi
|
||||
done
|
||||
set +f
|
||||
printf "python"
|
||||
}
|
||||
|
||||
PYTHON=$(search_for_python)
|
||||
echo Using python executable: $PYTHON
|
||||
|
||||
$PYTHON -c "import sys; script_launch=lambda:sys.exit('Download of installer failed!'); exec(sys.stdin.read()); script_launch()" "$@" <<'CALIBRE_LINUX_INSTALLER_HEREDOC'
|
||||
# {{{
|
||||
# HEREDOC_START
|
||||
#!/usr/bin/env python2
|
||||
# vim:fileencoding=utf-8
|
||||
# License: GPLv3 Copyright: 2009, Kovid Goyal <kovid at kovidgoyal.net>
|
||||
from __future__ import absolute_import, division, print_function, unicode_literals
|
||||
|
||||
import errno
|
||||
import hashlib
|
||||
import os
|
||||
import platform
|
||||
import re
|
||||
import shutil
|
||||
import signal
|
||||
import socket
|
||||
import ssl
|
||||
import stat
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
from contextlib import closing
|
||||
|
||||
is64bit = platform.architecture()[0] == '64bit'
|
||||
py3 = sys.version_info[0] > 2
|
||||
enc = getattr(sys.stdout, 'encoding', 'utf-8') or 'utf-8'
|
||||
if enc.lower() == 'ascii':
|
||||
enc = 'utf-8'
|
||||
dl_url = calibre_version = signature = None
|
||||
has_ssl_verify = hasattr(ssl, 'create_default_context')
|
||||
|
||||
if py3:
|
||||
unicode = str
|
||||
raw_input = input
|
||||
from urllib.parse import urlparse
|
||||
from urllib.request import BaseHandler, build_opener, Request, urlopen, getproxies, addinfourl
|
||||
import http.client as httplib
|
||||
encode_for_subprocess = lambda x:x
|
||||
else:
|
||||
from future_builtins import map
|
||||
from urlparse import urlparse
|
||||
from urllib import urlopen, getproxies, addinfourl
|
||||
from urllib2 import BaseHandler, build_opener, Request
|
||||
import httplib
|
||||
|
||||
def encode_for_subprocess(x):
|
||||
if isinstance(x, unicode):
|
||||
x = x.encode(enc)
|
||||
return x
|
||||
|
||||
|
||||
class TerminalController: # {{{
|
||||
BOL = '' #: Move the cursor to the beginning of the line
|
||||
UP = '' #: Move the cursor up one line
|
||||
DOWN = '' #: Move the cursor down one line
|
||||
LEFT = '' #: Move the cursor left one char
|
||||
RIGHT = '' #: Move the cursor right one char
|
||||
|
||||
# Deletion:
|
||||
CLEAR_SCREEN = '' #: Clear the screen and move to home position
|
||||
CLEAR_EOL = '' #: Clear to the end of the line.
|
||||
CLEAR_BOL = '' #: Clear to the beginning of the line.
|
||||
CLEAR_EOS = '' #: Clear to the end of the screen
|
||||
|
||||
# Output modes:
|
||||
BOLD = '' #: Turn on bold mode
|
||||
BLINK = '' #: Turn on blink mode
|
||||
DIM = '' #: Turn on half-bright mode
|
||||
REVERSE = '' #: Turn on reverse-video mode
|
||||
NORMAL = '' #: Turn off all modes
|
||||
|
||||
# Cursor display:
|
||||
HIDE_CURSOR = '' #: Make the cursor invisible
|
||||
SHOW_CURSOR = '' #: Make the cursor visible
|
||||
|
||||
# Terminal size:
|
||||
COLS = None #: Width of the terminal (None for unknown)
|
||||
LINES = None #: Height of the terminal (None for unknown)
|
||||
|
||||
# Foreground colors:
|
||||
BLACK = BLUE = GREEN = CYAN = RED = MAGENTA = YELLOW = WHITE = ''
|
||||
|
||||
# Background colors:
|
||||
BG_BLACK = BG_BLUE = BG_GREEN = BG_CYAN = ''
|
||||
BG_RED = BG_MAGENTA = BG_YELLOW = BG_WHITE = ''
|
||||
|
||||
_STRING_CAPABILITIES = """
|
||||
BOL=cr UP=cuu1 DOWN=cud1 LEFT=cub1 RIGHT=cuf1
|
||||
CLEAR_SCREEN=clear CLEAR_EOL=el CLEAR_BOL=el1 CLEAR_EOS=ed BOLD=bold
|
||||
BLINK=blink DIM=dim REVERSE=rev UNDERLINE=smul NORMAL=sgr0
|
||||
HIDE_CURSOR=cinvis SHOW_CURSOR=cnorm""".split()
|
||||
_COLORS = """BLACK BLUE GREEN CYAN RED MAGENTA YELLOW WHITE""".split()
|
||||
_ANSICOLORS = "BLACK RED GREEN YELLOW BLUE MAGENTA CYAN WHITE".split()
|
||||
|
||||
def __init__(self, term_stream=sys.stdout):
|
||||
# Curses isn't available on all platforms
|
||||
try:
|
||||
import curses
|
||||
except:
|
||||
return
|
||||
|
||||
# If the stream isn't a tty, then assume it has no capabilities.
|
||||
if not hasattr(term_stream, 'isatty') or not term_stream.isatty():
|
||||
return
|
||||
|
||||
# Check the terminal type. If we fail, then assume that the
|
||||
# terminal has no capabilities.
|
||||
try:
|
||||
curses.setupterm()
|
||||
except:
|
||||
return
|
||||
|
||||
# Look up numeric capabilities.
|
||||
self.COLS = curses.tigetnum('cols')
|
||||
self.LINES = curses.tigetnum('lines')
|
||||
|
||||
# Look up string capabilities.
|
||||
for capability in self._STRING_CAPABILITIES:
|
||||
(attrib, cap_name) = capability.split('=')
|
||||
setattr(self, attrib, self._escape_code(self._tigetstr(cap_name)))
|
||||
|
||||
# Colors
|
||||
set_fg = self._tigetstr('setf')
|
||||
if set_fg:
|
||||
if not isinstance(set_fg, bytes):
|
||||
set_fg = set_fg.encode('utf-8')
|
||||
for i,color in zip(range(len(self._COLORS)), self._COLORS):
|
||||
setattr(self, color,
|
||||
self._escape_code(curses.tparm((set_fg), i)))
|
||||
set_fg_ansi = self._tigetstr('setaf')
|
||||
if set_fg_ansi:
|
||||
if not isinstance(set_fg_ansi, bytes):
|
||||
set_fg_ansi = set_fg_ansi.encode('utf-8')
|
||||
for i,color in zip(range(len(self._ANSICOLORS)), self._ANSICOLORS):
|
||||
setattr(self, color,
|
||||
self._escape_code(curses.tparm((set_fg_ansi),
|
||||
i)))
|
||||
set_bg = self._tigetstr('setb')
|
||||
if set_bg:
|
||||
if not isinstance(set_bg, bytes):
|
||||
set_bg = set_bg.encode('utf-8')
|
||||
for i,color in zip(range(len(self._COLORS)), self._COLORS):
|
||||
setattr(self, 'BG_'+color,
|
||||
self._escape_code(curses.tparm((set_bg), i)))
|
||||
set_bg_ansi = self._tigetstr('setab')
|
||||
if set_bg_ansi:
|
||||
if not isinstance(set_bg_ansi, bytes):
|
||||
set_bg_ansi = set_bg_ansi.encode('utf-8')
|
||||
for i,color in zip(range(len(self._ANSICOLORS)), self._ANSICOLORS):
|
||||
setattr(self, 'BG_'+color,
|
||||
self._escape_code(curses.tparm((set_bg_ansi),
|
||||
i)))
|
||||
|
||||
def _escape_code(self, raw):
|
||||
if not raw:
|
||||
raw = ''
|
||||
if not isinstance(raw, unicode):
|
||||
raw = raw.decode('ascii')
|
||||
return raw
|
||||
|
||||
def _tigetstr(self, cap_name):
|
||||
# String capabilities can include "delays" of the form "$<2>".
|
||||
# For any modern terminal, we should be able to just ignore
|
||||
# these, so strip them out.
|
||||
import curses
|
||||
if isinstance(cap_name, bytes):
|
||||
cap_name = cap_name.decode('utf-8')
|
||||
cap = self._escape_code(curses.tigetstr(cap_name))
|
||||
return re.sub(r'\$<\d+>[/*]?', '', cap)
|
||||
|
||||
def render(self, template):
|
||||
return re.sub(r'\$\$|\${\w+}', self._render_sub, template)
|
||||
|
||||
def _render_sub(self, match):
|
||||
s = match.group()
|
||||
if s == '$$':
|
||||
return s
|
||||
else:
|
||||
return getattr(self, s[2:-1])
|
||||
|
||||
|
||||
class ProgressBar:
|
||||
BAR = '%3d%% ${GREEN}[${BOLD}%s%s${NORMAL}${GREEN}]${NORMAL}\n'
|
||||
HEADER = '${BOLD}${CYAN}%s${NORMAL}\n\n'
|
||||
|
||||
def __init__(self, term, header):
|
||||
self.term = term
|
||||
if not (self.term.CLEAR_EOL and self.term.UP and self.term.BOL):
|
||||
raise ValueError("Terminal isn't capable enough -- you "
|
||||
"should use a simpler progress display.")
|
||||
self.width = self.term.COLS or 75
|
||||
self.bar = term.render(self.BAR)
|
||||
self.header = self.term.render(self.HEADER % header.center(self.width))
|
||||
self.cleared = 1 # : true if we haven't drawn the bar yet.
|
||||
|
||||
def update(self, percent, message=''):
|
||||
out = (sys.stdout.buffer if py3 else sys.stdout)
|
||||
if self.cleared:
|
||||
out.write(self.header.encode(enc))
|
||||
self.cleared = 0
|
||||
n = int((self.width-10)*percent)
|
||||
msg = message.center(self.width)
|
||||
msg = (self.term.BOL + self.term.UP + self.term.CLEAR_EOL + (
|
||||
self.bar % (100*percent, '='*n, '-'*(self.width-10-n))) + self.term.CLEAR_EOL + msg).encode(enc)
|
||||
out.write(msg)
|
||||
out.flush()
|
||||
|
||||
def clear(self):
|
||||
out = (sys.stdout.buffer if py3 else sys.stdout)
|
||||
if not self.cleared:
|
||||
out.write((self.term.BOL + self.term.CLEAR_EOL + self.term.UP + self.term.CLEAR_EOL + self.term.UP + self.term.CLEAR_EOL).encode(enc))
|
||||
self.cleared = 1
|
||||
out.flush()
|
||||
# }}}
|
||||
|
||||
|
||||
def prints(*args, **kwargs): # {{{
|
||||
f = kwargs.get('file', sys.stdout.buffer if py3 else sys.stdout)
|
||||
end = kwargs.get('end', b'\n')
|
||||
enc = getattr(f, 'encoding', 'utf-8') or 'utf-8'
|
||||
|
||||
if isinstance(end, unicode):
|
||||
end = end.encode(enc)
|
||||
for x in args:
|
||||
if isinstance(x, unicode):
|
||||
x = x.encode(enc)
|
||||
f.write(x)
|
||||
f.write(b' ')
|
||||
f.write(end)
|
||||
if py3 and f is sys.stdout.buffer:
|
||||
f.flush()
|
||||
# }}}
|
||||
|
||||
|
||||
class Reporter: # {{{
|
||||
|
||||
def __init__(self, fname):
|
||||
try:
|
||||
self.pb = ProgressBar(TerminalController(), 'Downloading '+fname)
|
||||
except ValueError:
|
||||
prints('Downloading', fname)
|
||||
self.pb = None
|
||||
self.last_percent = 0
|
||||
|
||||
def __call__(self, blocks, block_size, total_size):
|
||||
percent = (blocks*block_size)/float(total_size)
|
||||
if self.pb is None:
|
||||
if percent - self.last_percent > 0.05:
|
||||
self.last_percent = percent
|
||||
prints('Downloaded {0:%}'.format(percent))
|
||||
else:
|
||||
try:
|
||||
self.pb.update(percent)
|
||||
except:
|
||||
import traceback
|
||||
traceback.print_exc()
|
||||
# }}}
|
||||
|
||||
|
||||
# Downloading {{{
|
||||
|
||||
def clean_cache(cache, fname):
|
||||
for x in os.listdir(cache):
|
||||
if fname not in x:
|
||||
os.remove(os.path.join(cache, x))
|
||||
|
||||
|
||||
def check_signature(dest, signature):
|
||||
if not os.path.exists(dest):
|
||||
return None
|
||||
m = hashlib.sha512()
|
||||
with open(dest, 'rb') as f:
|
||||
raw = f.read()
|
||||
m.update(raw)
|
||||
if m.hexdigest().encode('ascii') == signature:
|
||||
return raw
|
||||
|
||||
|
||||
class RangeHandler(BaseHandler):
|
||||
|
||||
def http_error_206(self, req, fp, code, msg, hdrs):
|
||||
# 206 Partial Content Response
|
||||
r = addinfourl(fp, hdrs, req.get_full_url())
|
||||
r.code = code
|
||||
r.msg = msg
|
||||
return r
|
||||
https_error_206 = http_error_206
|
||||
|
||||
|
||||
def do_download(dest):
|
||||
prints('Will download and install', os.path.basename(dest))
|
||||
reporter = Reporter(os.path.basename(dest))
|
||||
offset = 0
|
||||
if os.path.exists(dest):
|
||||
offset = os.path.getsize(dest)
|
||||
|
||||
# Get content length and check if range is supported
|
||||
rq = urlopen(dl_url)
|
||||
headers = rq.info()
|
||||
size = int(headers['content-length'])
|
||||
accepts_ranges = headers.get('accept-ranges', None) == 'bytes'
|
||||
mode = 'wb'
|
||||
if accepts_ranges and offset > 0:
|
||||
req = Request(rq.geturl())
|
||||
req.add_header('Range', 'bytes=%s-'%offset)
|
||||
mode = 'ab'
|
||||
rq.close()
|
||||
handler = RangeHandler()
|
||||
opener = build_opener(handler)
|
||||
rq = opener.open(req)
|
||||
with open(dest, mode) as f:
|
||||
while f.tell() < size:
|
||||
raw = rq.read(8192)
|
||||
if not raw:
|
||||
break
|
||||
f.write(raw)
|
||||
reporter(f.tell(), 1, size)
|
||||
rq.close()
|
||||
if os.path.getsize(dest) < size:
|
||||
print ('Download failed, try again later')
|
||||
raise SystemExit(1)
|
||||
prints('Downloaded %s bytes'%os.path.getsize(dest))
|
||||
|
||||
|
||||
def download_tarball():
|
||||
fname = 'calibre-%s-i686.%s'%(calibre_version, 'txz')
|
||||
if is64bit:
|
||||
fname = fname.replace('i686', 'x86_64')
|
||||
tdir = tempfile.gettempdir()
|
||||
cache = os.path.join(tdir, 'calibre-installer-cache')
|
||||
if not os.path.exists(cache):
|
||||
os.makedirs(cache)
|
||||
clean_cache(cache, fname)
|
||||
dest = os.path.join(cache, fname)
|
||||
raw = check_signature(dest, signature)
|
||||
if raw is not None:
|
||||
print('Using previously downloaded', fname)
|
||||
return raw
|
||||
cached_sigf = dest +'.signature'
|
||||
cached_sig = None
|
||||
if os.path.exists(cached_sigf):
|
||||
with open(cached_sigf, 'rb') as sigf:
|
||||
cached_sig = sigf.read()
|
||||
if cached_sig != signature and os.path.exists(dest):
|
||||
os.remove(dest)
|
||||
try:
|
||||
with open(cached_sigf, 'wb') as f:
|
||||
f.write(signature)
|
||||
except IOError as e:
|
||||
if e.errno != errno.EACCES:
|
||||
raise
|
||||
print ('The installer cache directory has incorrect permissions.'
|
||||
' Delete %s and try again.'%cache)
|
||||
raise SystemExit(1)
|
||||
do_download(dest)
|
||||
prints('Checking downloaded file integrity...')
|
||||
raw = check_signature(dest, signature)
|
||||
if raw is None:
|
||||
os.remove(dest)
|
||||
print ('The downloaded files\' signature does not match. '
|
||||
'Try the download again later.')
|
||||
raise SystemExit(1)
|
||||
return raw
|
||||
# }}}
|
||||
|
||||
|
||||
# Get tarball signature securely {{{
|
||||
|
||||
def get_proxies(debug=True):
|
||||
proxies = getproxies()
|
||||
for key, proxy in list(proxies.items()):
|
||||
if not proxy or '..' in proxy:
|
||||
del proxies[key]
|
||||
continue
|
||||
if proxy.startswith(key+'://'):
|
||||
proxy = proxy[len(key)+3:]
|
||||
if key == 'https' and proxy.startswith('http://'):
|
||||
proxy = proxy[7:]
|
||||
if proxy.endswith('/'):
|
||||
proxy = proxy[:-1]
|
||||
if len(proxy) > 4:
|
||||
proxies[key] = proxy
|
||||
else:
|
||||
prints('Removing invalid', key, 'proxy:', proxy)
|
||||
del proxies[key]
|
||||
|
||||
if proxies and debug:
|
||||
prints('Using proxies:', repr(proxies))
|
||||
return proxies
|
||||
|
||||
|
||||
class HTTPError(ValueError):
|
||||
|
||||
def __init__(self, url, code):
|
||||
msg = '%s returned an unsupported http response code: %d (%s)' % (
|
||||
url, code, httplib.responses.get(code, None))
|
||||
ValueError.__init__(self, msg)
|
||||
self.code = code
|
||||
self.url = url
|
||||
|
||||
|
||||
class CertificateError(ValueError):
|
||||
pass
|
||||
|
||||
|
||||
def _dnsname_match(dn, hostname, max_wildcards=1):
|
||||
"""Matching according to RFC 6125, section 6.4.3
|
||||
|
||||
http://tools.ietf.org/html/rfc6125#section-6.4.3
|
||||
"""
|
||||
pats = []
|
||||
if not dn:
|
||||
return False
|
||||
|
||||
parts = dn.split(r'.')
|
||||
leftmost, remainder = parts[0], parts[1:]
|
||||
|
||||
wildcards = leftmost.count('*')
|
||||
if wildcards > max_wildcards:
|
||||
# Issue #17980: avoid denials of service by refusing more
|
||||
# than one wildcard per fragment. A survery of established
|
||||
# policy among SSL implementations showed it to be a
|
||||
# reasonable choice.
|
||||
raise CertificateError(
|
||||
"too many wildcards in certificate DNS name: " + repr(dn))
|
||||
|
||||
# speed up common case w/o wildcards
|
||||
if not wildcards:
|
||||
return dn.lower() == hostname.lower()
|
||||
|
||||
# RFC 6125, section 6.4.3, subitem 1.
|
||||
# The client SHOULD NOT attempt to match a presented identifier in which
|
||||
# the wildcard character comprises a label other than the left-most label.
|
||||
if leftmost == '*':
|
||||
# When '*' is a fragment by itself, it matches a non-empty dotless
|
||||
# fragment.
|
||||
pats.append('[^.]+')
|
||||
elif leftmost.startswith('xn--') or hostname.startswith('xn--'):
|
||||
# RFC 6125, section 6.4.3, subitem 3.
|
||||
# The client SHOULD NOT attempt to match a presented identifier
|
||||
# where the wildcard character is embedded within an A-label or
|
||||
# U-label of an internationalized domain name.
|
||||
pats.append(re.escape(leftmost))
|
||||
else:
|
||||
# Otherwise, '*' matches any dotless string, e.g. www*
|
||||
pats.append(re.escape(leftmost).replace(r'\*', '[^.]*'))
|
||||
|
||||
# add the remaining fragments, ignore any wildcards
|
||||
for frag in remainder:
|
||||
pats.append(re.escape(frag))
|
||||
|
||||
pat = re.compile(r'\A' + r'\.'.join(pats) + r'\Z', re.IGNORECASE)
|
||||
return pat.match(hostname)
|
||||
|
||||
|
||||
def match_hostname(cert, hostname):
|
||||
"""Verify that *cert* (in decoded format as returned by
|
||||
SSLSocket.getpeercert()) matches the *hostname*. RFC 2818 and RFC 6125
|
||||
rules are followed, but IP addresses are not accepted for *hostname*.
|
||||
|
||||
CertificateError is raised on failure. On success, the function
|
||||
returns nothing.
|
||||
"""
|
||||
if not cert:
|
||||
raise ValueError("empty or no certificate")
|
||||
dnsnames = []
|
||||
san = cert.get('subjectAltName', ())
|
||||
for key, value in san:
|
||||
if key == 'DNS':
|
||||
if _dnsname_match(value, hostname):
|
||||
return
|
||||
dnsnames.append(value)
|
||||
if not dnsnames:
|
||||
# The subject is only checked when there is no dNSName entry
|
||||
# in subjectAltName
|
||||
for sub in cert.get('subject', ()):
|
||||
for key, value in sub:
|
||||
# XXX according to RFC 2818, the most specific Common Name
|
||||
# must be used.
|
||||
if key == 'commonName':
|
||||
if _dnsname_match(value, hostname):
|
||||
return
|
||||
dnsnames.append(value)
|
||||
|
||||
if len(dnsnames) > 1:
|
||||
raise CertificateError("hostname %r "
|
||||
"doesn't match either of %s"
|
||||
% (hostname, ', '.join(map(repr, dnsnames))))
|
||||
elif len(dnsnames) == 1:
|
||||
# python 2.7.2 does not read subject alt names thanks to this
|
||||
# bug: http://bugs.python.org/issue13034
|
||||
# And the utter lunacy that is the linux landscape could have
|
||||
# any old version of python whatsoever with or without a hot fix for
|
||||
# this bug. Not to mention that python 2.6 may or may not
|
||||
# read alt names depending on its patchlevel. So we just bail on full
|
||||
# verification if the python version is less than 2.7.3.
|
||||
# Linux distros are one enormous, honking disaster.
|
||||
if sys.version_info[:3] < (2, 7, 3) and dnsnames[0] == 'calibre-ebook.com':
|
||||
return
|
||||
raise CertificateError("hostname %r "
|
||||
"doesn't match %r"
|
||||
% (hostname, dnsnames[0]))
|
||||
else:
|
||||
raise CertificateError("no appropriate commonName or "
|
||||
"subjectAltName fields were found")
|
||||
|
||||
|
||||
if has_ssl_verify:
|
||||
class HTTPSConnection(httplib.HTTPSConnection):
|
||||
|
||||
def __init__(self, ssl_version, *args, **kwargs):
|
||||
kwargs['context'] = ssl.create_default_context(cafile=kwargs.pop('cert_file'))
|
||||
httplib.HTTPSConnection.__init__(self, *args, **kwargs)
|
||||
else:
|
||||
class HTTPSConnection(httplib.HTTPSConnection):
|
||||
|
||||
def __init__(self, ssl_version, *args, **kwargs):
|
||||
httplib.HTTPSConnection.__init__(self, *args, **kwargs)
|
||||
self.calibre_ssl_version = ssl_version
|
||||
|
||||
def connect(self):
|
||||
"""Connect to a host on a given (SSL) port, properly verifying the SSL
|
||||
certificate, both that it is valid and that its declared hostnames
|
||||
match the hostname we are connecting to."""
|
||||
|
||||
if hasattr(self, 'source_address'):
|
||||
sock = socket.create_connection((self.host, self.port),
|
||||
self.timeout, self.source_address)
|
||||
else:
|
||||
# python 2.6 has no source_address
|
||||
sock = socket.create_connection((self.host, self.port), self.timeout)
|
||||
if self._tunnel_host:
|
||||
self.sock = sock
|
||||
self._tunnel()
|
||||
self.sock = ssl.wrap_socket(sock, cert_reqs=ssl.CERT_REQUIRED, ca_certs=self.cert_file, ssl_version=self.calibre_ssl_version)
|
||||
getattr(ssl, 'match_hostname', match_hostname)(self.sock.getpeercert(), self.host)
|
||||
|
||||
CACERT = b'''\
|
||||
-----BEGIN CERTIFICATE-----
|
||||
MIIFzjCCA7agAwIBAgIJAKfuFL6Cvpn4MA0GCSqGSIb3DQEBCwUAMGIxCzAJBgNV
|
||||
BAYTAklOMRQwEgYDVQQIDAtNYWhhcmFzaHRyYTEPMA0GA1UEBwwGTXVtYmFpMRAw
|
||||
DgYDVQQKDAdjYWxpYnJlMRowGAYDVQQDDBFjYWxpYnJlLWVib29rLmNvbTAgFw0x
|
||||
NTEyMjMwNTQ2NTlaGA8yMTE1MTEyOTA1NDY1OVowYjELMAkGA1UEBhMCSU4xFDAS
|
||||
BgNVBAgMC01haGFyYXNodHJhMQ8wDQYDVQQHDAZNdW1iYWkxEDAOBgNVBAoMB2Nh
|
||||
bGlicmUxGjAYBgNVBAMMEWNhbGlicmUtZWJvb2suY29tMIICIjANBgkqhkiG9w0B
|
||||
AQEFAAOCAg8AMIICCgKCAgEAtlbeAxQKyWhoxwaGqMh5ktRhqsLR6uzjuqWmB+Mm
|
||||
fC0Ni45mOSo2R/usFQTZesrYUoo2yBhMN58CsLeuaaQfsPeDss7zJ9jX0v/GYUS3
|
||||
vM7qE55ruRWu0g11NpuWLZkqvcw5gVi3ZJYx/yqTEGlCDGxjXVs9iEg+L75Bcm9y
|
||||
87olbcZA6H/CbR5lP1/tXcyyb1TBINuTcg408SnieY/HpnA1r3NQB9MwfScdX08H
|
||||
TB0Bc8e0qz+r1BNi3wZZcrNpqWhw6X9QkHigGaDNppmWqc1Q5nxxk2rC21GRg56n
|
||||
p6t3ENQMctE3KTJfR8TwM33N/dfcgobDZ/ZTnogqdFQycFOgvT4mIZsXdsJv6smy
|
||||
hlkUqye2PV8XcTNJr+wRzIN/+u23jC+CaT0U0A57D8PUZVhT+ZshXjB91Ko8hLE1
|
||||
SmJkdv2bxFV42bsemhSxZWCtsc2Nv8/Ds+WVV00xfADym+LokzEqqfcK9vkkMGzF
|
||||
h7wzd7YqPOrMGOCe9vH1CoL3VO5srPV+0Mp1fjIGgm5SIhklyRfaeIjFeyoDRA6e
|
||||
8EXrI3xOsrkXXMJDvhndEJOYYqplY+4kLhW0XeTZjK7CmD59xRtFYWaV3dcMlaWb
|
||||
VxuY7dgsiO7iUztYY0To5ZDExcHem7PEPUTyFii9LhbcSJeXDaqPFMxih+X0iqKv
|
||||
ni8CAwEAAaOBhDCBgTAxBgNVHREEKjAoghFjYWxpYnJlLWVib29rLmNvbYITKi5j
|
||||
YWxpYnJlLWVib29rLmNvbTAdBgNVHQ4EFgQURWqz5EOg5K1OrSKpleR+louVxsQw
|
||||
HwYDVR0jBBgwFoAURWqz5EOg5K1OrSKpleR+louVxsQwDAYDVR0TBAUwAwEB/zAN
|
||||
BgkqhkiG9w0BAQsFAAOCAgEAS1+Jx0VyTrEFUQ5jEIx/7WrL4GDnzxjeXWJTyKSk
|
||||
YqcOvXZpwwrTHJSGHj7MpCqWIzQnHxICBFlUEVcb1g1UPvNB5OY69eLjlYdwfOK9
|
||||
bfp/KnLCsn7Pf4UCATRslX9J1LV6r17X2ONWWmSutDeGP1azXVxwFsogvvqwPHCs
|
||||
nlfvQycUcd4HWIZWBJ1n4Ry6OwdpFuHktRVtNtTlD34KUjzcN2GCA08Ur+1eiA9D
|
||||
/Oru1X4hfA3gbiAlGJ/+3AQw0oYS0IEW1HENurkIDNs98CXTiau9OXRECgGjE3hC
|
||||
viECb4beyhEOH5y1dQJZEynwvSepFG8wDJWmkVN7hMrfbZF4Ec0BmsJpbuq5GrdV
|
||||
cXUXJbLrnADFV9vkciLb3pl7gAmHi1T19i/maWMiYqIAh7Ezi/h6ufGbPiG+vfLt
|
||||
f4ywTKQeQKAamBW4P2oFgcmlPDlDeVFWdkF1aC0WFct5/R7Fea0D2bOVt52zm3v3
|
||||
Ghni3NYEZzXHf08c8tzXZmM1Q39sSS1vn2B9PgiYj87Xg9Fxn1trKFdsiry1F2Qx
|
||||
qDq1u+xTdjPKwVVB1zd5g3MM/YYTVRhuH2AZU/Z4qX8DAf9ESqLqUpEOpyvLkX3r
|
||||
gENtRgsmhjlf/Qwymuz8nnzJD5c4TgCicVjPNArprVtmyfOXLVXJLC+KpkzTxvdr
|
||||
nR0=
|
||||
-----END CERTIFICATE-----
|
||||
'''
|
||||
|
||||
|
||||
def get_https_resource_securely(url, timeout=60, max_redirects=5, ssl_version=None):
|
||||
'''
|
||||
Download the resource pointed to by url using https securely (verify server
|
||||
certificate). Ensures that redirects, if any, are also downloaded
|
||||
securely. Needs a CA certificates bundle (in PEM format) to verify the
|
||||
server's certificates.
|
||||
'''
|
||||
if ssl_version is None:
|
||||
try:
|
||||
ssl_version = ssl.PROTOCOL_TLSv1_2
|
||||
except AttributeError:
|
||||
ssl_version = ssl.PROTOCOL_TLSv1 # old python
|
||||
with tempfile.NamedTemporaryFile(prefix='calibre-ca-cert-') as f:
|
||||
f.write(CACERT)
|
||||
f.flush()
|
||||
p = urlparse(url)
|
||||
if p.scheme != 'https':
|
||||
raise ValueError('URL %s scheme must be https, not %r' % (url, p.scheme))
|
||||
|
||||
hostname, port = p.hostname, p.port
|
||||
proxies = get_proxies()
|
||||
has_proxy = False
|
||||
for q in ('https', 'http'):
|
||||
if q in proxies:
|
||||
try:
|
||||
h, po = proxies[q].rpartition(':')[::2]
|
||||
po = int(po)
|
||||
if h:
|
||||
hostname, port, has_proxy = h, po, True
|
||||
break
|
||||
except Exception:
|
||||
# Invalid proxy, ignore
|
||||
pass
|
||||
|
||||
c = HTTPSConnection(ssl_version, hostname, port, cert_file=f.name, timeout=timeout)
|
||||
if has_proxy:
|
||||
c.set_tunnel(p.hostname, p.port)
|
||||
|
||||
with closing(c):
|
||||
c.connect() # This is needed for proxy connections
|
||||
path = p.path or '/'
|
||||
if p.query:
|
||||
path += '?' + p.query
|
||||
c.request('GET', path)
|
||||
response = c.getresponse()
|
||||
if response.status in (httplib.MOVED_PERMANENTLY, httplib.FOUND, httplib.SEE_OTHER):
|
||||
if max_redirects <= 0:
|
||||
raise ValueError('Too many redirects, giving up')
|
||||
newurl = response.getheader('Location', None)
|
||||
if newurl is None:
|
||||
raise ValueError('%s returned a redirect response with no Location header' % url)
|
||||
return get_https_resource_securely(
|
||||
newurl, timeout=timeout, max_redirects=max_redirects-1, ssl_version=ssl_version)
|
||||
if response.status != httplib.OK:
|
||||
raise HTTPError(url, response.status)
|
||||
return response.read()
|
||||
# }}}
|
||||
|
||||
|
||||
def extract_tarball(raw, destdir):
|
||||
prints('Extracting application files...')
|
||||
with open('/dev/null', 'w') as null:
|
||||
p = subprocess.Popen(
|
||||
list(map(encode_for_subprocess, ['tar', 'xJof', '-', '-C', destdir])),
|
||||
stdout=null, stdin=subprocess.PIPE, close_fds=True, preexec_fn=lambda:
|
||||
signal.signal(signal.SIGPIPE, signal.SIG_DFL))
|
||||
p.stdin.write(raw)
|
||||
p.stdin.close()
|
||||
if p.wait() != 0:
|
||||
prints('Extracting of application files failed with error code: %s' % p.returncode)
|
||||
raise SystemExit(1)
|
||||
|
||||
|
||||
def get_tarball_info(version):
|
||||
global dl_url, signature, calibre_version
|
||||
print ('Downloading tarball signature securely...')
|
||||
if version:
|
||||
signature = get_https_resource_securely(
|
||||
'https://code.calibre-ebook.com/signatures/calibre-' + version + '-' + ('x86_64' if is64bit else 'i686') + '.txz.sha512')
|
||||
calibre_version = version
|
||||
dl_url = 'https://download.calibre-ebook.com/' + version + '/calibre-' + version + '-' + ('x86_64' if is64bit else 'i686') + '.txz'
|
||||
else:
|
||||
raw = get_https_resource_securely(
|
||||
'https://code.calibre-ebook.com/tarball-info/' + ('x86_64' if is64bit else 'i686'))
|
||||
signature, calibre_version = raw.rpartition(b'@')[::2]
|
||||
dl_url = 'https://calibre-ebook.com/dist/linux'+('64' if is64bit else '32')
|
||||
if not signature or not calibre_version:
|
||||
raise ValueError('Failed to get install file signature, invalid signature returned')
|
||||
dl_url = os.environ.get('CALIBRE_INSTALLER_LOCAL_URL', dl_url)
|
||||
if isinstance(calibre_version, bytes):
|
||||
calibre_version = calibre_version.decode('utf-8')
|
||||
|
||||
|
||||
def download_and_extract(destdir, version):
|
||||
get_tarball_info(version)
|
||||
raw = download_tarball()
|
||||
|
||||
if os.path.exists(destdir):
|
||||
shutil.rmtree(destdir)
|
||||
os.makedirs(destdir)
|
||||
|
||||
print('Extracting files to %s ...'%destdir)
|
||||
extract_tarball(raw, destdir)
|
||||
|
||||
|
||||
def check_version():
|
||||
global calibre_version
|
||||
if calibre_version == '%version':
|
||||
calibre_version = urlopen('http://code.calibre-ebook.com/latest').read()
|
||||
|
||||
|
||||
def run_installer(install_dir, isolated, bin_dir, share_dir, version):
|
||||
destdir = os.path.abspath(os.path.expanduser(install_dir or '/opt'))
|
||||
if destdir == '/usr/bin':
|
||||
prints(destdir, 'is not a valid install location. Choose', end='')
|
||||
prints('a location like /opt or /usr/local')
|
||||
return 1
|
||||
destdir = os.path.realpath(os.path.join(destdir, 'calibre'))
|
||||
if os.path.exists(destdir):
|
||||
if not os.path.isdir(destdir):
|
||||
prints(destdir, 'exists and is not a directory. Choose a location like /opt or /usr/local')
|
||||
return 1
|
||||
print('Installing to', destdir)
|
||||
|
||||
download_and_extract(destdir, version)
|
||||
|
||||
if not isolated:
|
||||
pi = [os.path.join(destdir, 'calibre_postinstall')]
|
||||
if bin_dir is not None:
|
||||
pi.extend(['--bindir', bin_dir])
|
||||
if share_dir is not None:
|
||||
pi.extend(['--sharedir', share_dir])
|
||||
subprocess.call(pi)
|
||||
prints('Run "calibre" to start calibre')
|
||||
else:
|
||||
prints('Run "%s/calibre" to start calibre' % destdir)
|
||||
return 0
|
||||
|
||||
|
||||
def check_umask():
|
||||
# A bad umask can cause system breakage because of bugs in xdg-mime
|
||||
# See https://www.mobileread.com/forums/showthread.php?t=277803
|
||||
mask = os.umask(18) # 18 = 022
|
||||
os.umask(mask)
|
||||
forbid_user_read = mask & stat.S_IRUSR
|
||||
forbid_user_exec = mask & stat.S_IXUSR
|
||||
forbid_group_read = mask & stat.S_IRGRP
|
||||
forbid_group_exec = mask & stat.S_IXGRP
|
||||
forbid_other_read = mask & stat.S_IROTH
|
||||
forbid_other_exec = mask & stat.S_IXOTH
|
||||
if forbid_user_read or forbid_user_exec or forbid_group_read or forbid_group_exec or forbid_other_read or forbid_other_exec:
|
||||
prints(
|
||||
'WARNING: Your current umask disallows reading of files by some users,'
|
||||
' this can cause system breakage when running the installer because'
|
||||
' of bugs in common system utilities.'
|
||||
)
|
||||
sys.stdin = open('/dev/tty') # stdin is a pipe from wget
|
||||
while True:
|
||||
q = raw_input('Should the installer (f)ix the umask, (i)gnore it or (a)bort [f/i/a Default is abort]: ') or 'a'
|
||||
if q in 'f i a'.split():
|
||||
break
|
||||
prints('Response', q, 'not understood')
|
||||
if q == 'f':
|
||||
mask = mask & ~stat.S_IRUSR & ~stat.S_IXUSR & ~stat.S_IRGRP & ~stat.S_IXGRP & ~stat.S_IROTH & ~stat.S_IXOTH
|
||||
os.umask(mask)
|
||||
prints('umask changed to: {:03o}'.format(mask))
|
||||
elif q == 'i':
|
||||
prints('Ignoring bad umask and proceeding anyway, you have been warned!')
|
||||
else:
|
||||
raise SystemExit('The system umask is unsuitable, aborting')
|
||||
|
||||
|
||||
def main(install_dir=None, isolated=False, bin_dir=None, share_dir=None, ignore_umask=False, version=None):
|
||||
if not ignore_umask and not isolated:
|
||||
check_umask()
|
||||
machine = os.uname()[4]
|
||||
if machine and machine.lower().startswith('arm'):
|
||||
raise SystemExit(
|
||||
'You are running on an ARM system. The calibre binaries are only'
|
||||
' available for x86 systems. You will have to compile from'
|
||||
' source.')
|
||||
run_installer(install_dir, isolated, bin_dir, share_dir, version)
|
||||
|
||||
|
||||
try:
|
||||
__file__
|
||||
from_file = True
|
||||
except NameError:
|
||||
from_file = False
|
||||
|
||||
|
||||
def update_intaller_wrapper():
|
||||
# To run: python3 -c "import runpy; runpy.run_path('setup/linux-installer.py', run_name='update_wrapper')"
|
||||
with open(__file__, 'rb') as f:
|
||||
src = f.read().decode('utf-8')
|
||||
wrapper = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'linux-installer.sh')
|
||||
with open(wrapper, 'r+b') as f:
|
||||
raw = f.read().decode('utf-8')
|
||||
nraw = re.sub(r'^# HEREDOC_START.+^# HEREDOC_END', lambda m: '# HEREDOC_START\n{}\n# HEREDOC_END'.format(src), raw, flags=re.MULTILINE | re.DOTALL)
|
||||
if 'update_intaller_wrapper()' not in nraw:
|
||||
raise SystemExit('regex substitute of HEREDOC failed')
|
||||
f.seek(0), f.truncate()
|
||||
f.write(nraw.encode('utf-8'))
|
||||
|
||||
|
||||
def script_launch():
|
||||
def path(x):
|
||||
return os.path.expanduser(x)
|
||||
|
||||
def to_bool(x):
|
||||
return x.lower() in ('y', 'yes', '1', 'true')
|
||||
|
||||
type_map = {x: path for x in 'install_dir isolated bin_dir share_dir ignore_umask version'.split()}
|
||||
type_map['isolated'] = type_map['ignore_umask'] = to_bool
|
||||
kwargs = {}
|
||||
|
||||
for arg in sys.argv[1:]:
|
||||
if arg:
|
||||
m = re.match('([a-z_]+)=(.+)', arg)
|
||||
if m is None:
|
||||
raise SystemExit('Unrecognized command line argument: ' + arg)
|
||||
k = m.group(1)
|
||||
if k not in type_map:
|
||||
raise SystemExit('Unrecognized command line argument: ' + arg)
|
||||
kwargs[k] = type_map[k](m.group(2))
|
||||
main(**kwargs)
|
||||
|
||||
|
||||
if __name__ == '__main__' and from_file:
|
||||
main()
|
||||
elif __name__ == 'update_wrapper':
|
||||
update_intaller_wrapper()
|
||||
|
||||
# HEREDOC_END
|
||||
# }}}
|
||||
CALIBRE_LINUX_INSTALLER_HEREDOC
|
||||
Reference in New Issue
Block a user