import socket, string, SSLeay
import nntplib, ftplib, httplib

from urllib import *

# Standard ports used for secure services
HTTPS_PORT = 443
SNNTP_PORT = 563
  
class SSL_URLopener(URLopener):
  # Use FTP protocol
  def open_ftps(self, url):
    host, path = splithost(url)
    if not host: raise IOError, ('ftp error', 'no host given')
    host, port = splitport(host)
    user, host = splituser(host)
    if user: user, passwd = splitpasswd(user)
    else: passwd = None
    host = socket.gethostbyname(host)
    if not port:
      import ftplib
      port = ftplib.FTP_PORT
    path, attrs = splitattr(path)
    dirs = string.splitfields(path, '/')
    dirs, file = dirs[:-1], dirs[-1]
    if dirs and not dirs[0]: dirs = dirs[1:]
    key = (user, host, port, string.joinfields(dirs, '/'))
    try:
      if not self.ftpcache.has_key(key):
        self.ftpcache[key] = \
               SSLftpwrapper(user, passwd,
                    host, port, dirs)
      if not file: type = 'D'
      else: type = 'I'
      for attr in attrs:
        attr, value = splitvalue(attr)
        if string.lower(attr) == 'type' and \
           value in ('a', 'A', 'i', 'I', 'd', 'D'):
          type = string.upper(value)
      return addinfourl(self.ftpcache[key].retrfile(file, type),
          noheaders(), self.openedurl)
    except ftperrors(), msg:
      raise IOError, ('ftp error', msg)

  # Use HTTP protocol -- handle proxying of SSL URLs
  def open_http(self, url, SSL=0):
    import httplib
    SSL_proxying=0
    user_passwd=''
    if type(url) is type(""):
      host, selector = splithost(url)
      user_passwd, host = splituser(host)
    else:
      host, selector = url
      urltype, rest = splittype(selector)
      urltype=string.lower(urltype)
      if urltype in ['http', 'https']:
          realhost, rest = splithost(rest)
          user_passwd, realhost = splituser(realhost)
          if user_passwd:
        selector = "%s://%s%s" % (urltype,
                realhost, rest)
          if urltype=='https': SSL_proxying=1
      else:
          realhost, rest = splithost(rest)
          user_passwd, realhost = splituser(realhost)
      print "proxy via http:", host, selector
    if not host: raise IOError, ('http error', 'no host given')
    if user_passwd:
      import base64
      auth = string.strip(base64.encodestring(user_passwd))
    else:
      auth = None
      
    h = SSL_HTTP(host, SSL=SSL)

    # If we're proxying an https:// URL, the standard
    # procedure seems to be:  
    #   * Client issues CONNECT www.rsa.com:443 HTTP/1.0
                #   * Proxy replies with headers, & then serves as an
    #     intermediary
                #   * Client & SSL server perform SSL negotiation; the
    #     proxy simply copies bytes back and forth.
                #   * Client sends HTTP request; server replies, etc.
    # XXX should the auths be sent to the proxy, or the
    # SSL host?  Or both?
    if SSL_proxying: 
        SSLtype, SSLhost=splittype(selector)
        selector=selector[len(SSLtype)+1:]
        SSLhost, selector = splithost(selector)
        if not ':' in SSLhost: SSLhost=SSLhost+':'+str(HTTPS_PORT)
        h.putrequest('CONNECT', SSLhost)
    else: h.putrequest('GET', selector)
    if auth: h.putheader('Authorization: Basic %s' % auth)
    for args in self.addheaders: apply(h.putheader, args)
    h.endheaders()
    errcode, errmsg, headers = h.getreply()
    fp = h.getfile()
    if errcode == 200:
        if not SSL_proxying: 
      return addinfourl(fp, headers, self.openedurl)
        else: 
      fp=SSLeay.fromfd(fp.fileno() ) 
      fp.connect()
      # Whew!  Now we go through all this again!
      h=SSL_HTTP()
      h.connect(SSLhost, sock=fp)
      h.putrequest('GET', selector)
      h.endheaders()
      errcode, errmsg, headers = h.getreply()
      fp = h.getfile()
      if errcode==200: return addinfourl(fp, headers, self.openedurl)
      else: return self.http_error(url, fp, errcode, errmsg, headers)
    else:
      return self.http_error(url,
                 fp, errcode, errmsg, headers)

  # Use HTTP protocol via SSL
  def open_https(self, url):
          return self.open_http(url, SSL=1)

# Helper class, needed for ftps support
class SSLftpwrapper(ftpwrapper):
  def __init__(self, user, passwd, host, port, dirs):
      self.SSL=1
      ftpwrapper.__init__(self, user, passwd, host, port, dirs)
  def init(self):
    self.ftp = SSL_FTP(SSL=self.SSL)
    self.ftp.connect(self.host, self.port)
    self.ftp.login(self.user, self.passwd)
    for dir in self.dirs:
      self.ftp.cwd(dir)


class SSL_HTTP(httplib.HTTP):
    def __init__(self, host = '', port = 0, SSL = 0):
      self.debuglevel = 0 # XXX
      self.SSL=SSL
      self.file = None
      if host: self.connect(host, port)
    def connect(self, host, port = 0, sock=None):
      if not port:
        i = string.find(host, ':')
        if i >= 0:
          host, port = host[:i], host[i+1:]
          try: port = string.atoi(port)
          except string.atoi_error:
        raise socket.error, "nonnumeric port"
      if not port:
    if not self.SSL: port = httplib.HTTP_PORT
    else: port=HTTPS_PORT
    
      if sock==None:
    self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    if self.debuglevel > 0: print 'connect:', (host, port)
    self.sock.connect(host, port)
      else: 
    self.sock=sock

      # Once the connection is made, activate SSL if desired
      if self.SSL:
    import SSLeay 
    self.sock=SSLeay.fromfd(self.sock.fileno())
    if self.debuglevel > 0: print 'SSL connect'
    self.sock.connect()
    if self.debuglevel > 0:
        print 'Cipher algorithm:', self.sock.cipher
        x=self.sock.peer_cert
        print "Peer's Issuer:", x.oneline_issuer_name
        print "Peer's Subject:", x.oneline_subject


class SSL_NNTP(nntplib.NNTP):
    # Initialize an instance.  Arguments:
    # - host: hostname to connect to
    # - port: port to connect to (default the standard NNTP port)

    def __init__(self, host, port = -1, SSL=0):
      self.host = host ; self.SSL=SSL
      if port==-1:
    if not SSL: self.port=nntplib.NNTP_PORT
    else: self.port=SNNTP_PORT
      else: self.port=port
      self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
      self.sock.connect(self.host, self.port)
      if SSL:
    # Perform the SSL negotiation
    import SSLeay
    self.sock=SSLeay.fromfd(self.sock.fileno())
    self.sock.connect()
      self.file = self.sock.makefile('rb')
      self.debugging = 0
      self.welcome = self.getresp()

# This code works with SSLftpd, which is the only SSL FTP server I
# know of.  (Is there an RFC anywhere for SSL-FTP?)

class SSL_FTP(ftplib.FTP):
  # Initialization method (called by class instantiation).
  # Initialize host to localhost, port to standard ftp port
  # Optional arguments are host (for connect()),
  # and user, passwd, acct (for login())
  def __init__(self, host = '', user = '', passwd = '', acct = '',
         SSL = 0):
     self.SSL=SSL
    ftplib.FTP.__init__(self, host, user, passwd, acct)

        def login(self, user = '', passwd = '', acct = ''):
      ftplib.FTP.login(self, user, passwd, acct)
      self.__sockname=self.sock.getsockname()
      if self.SSL:
    try:
        if self.debugging: print 'sending AUTH SSL'
        self.putcmd('AUTH SSL')
        resp=self.getresp()
        # OK... SSL encryption is supported
        if self.debugging: print 'SSL accepted; negotiating'
        self.file=self.sock=SSLeay.fromfd(self.sock.fileno())
        self.sock.connect()
        if self.debugging:
      print 'Cipher algorithm:', self.sock.cipher
      x=self.sock.peer_cert
      print "Peer's Issuer:", x.oneline_issuer_name
      print "Peer's Subject:", x.oneline_subject
#        self.set_pasv(1)
    except ftplib.error_perm, resp:
        # The server doesn't support SSL
        self.SSL=0
        if self.debugging: print 'ftp server doesn\'t support SSL'

  def transfercmd(self, cmd):
    '''Initiate a transfer over the data connection.
    If the transfer is active, send a port command and
    the transfer command, and accept the connection.
    If the server is passive, send a pasv command, connect
    to it, and start the transfer command.
    Either way, return the socket for the connection'''
    if self.passiveserver:
      host, port = ftplib.parse227(self.sendcmd('PASV'))
      conn = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
      conn.connect(host, port)
      if self.SSL:
          if self.debugging: print 'SSL connect()'
          conn=SSLeay.fromfd(conn.fileno())
          if self.debugging: print 'SSL connect2()'
          conn.connect()
          if self.debugging: print 'SSL connect3()'
          if self.debugging: print 'SSL cipher=', conn.cipher
      resp = self.sendcmd(cmd)
      if resp[0] <> '1':
        raise ftplib.error_reply, resp
    else:
      sock = self.makeport()
      resp = self.sendcmd(cmd)
      if resp[0] <> '1':
        raise ftplib.error_reply, resp
      conn, sockaddr = sock.accept()
      if self.SSL:
          conn=SSLeay.fromfd(conn.fileno())
          # XXX The following won't work, since we
                # haven't defined a certificate to use.
          if self.debugging: print 'SSL connect()'
          conn.connect()
          if self.debugging: print 'SSL cipher=', conn.cipher
          file=conn.makefile()
    return conn

  def makeport(self):
    '''Create a new socket and send a PORT command for it.'''
    global nextport
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.bind(('', 0))
    sock.listen(1)
    dummyhost, port = sock.getsockname() # Get proper port
    host, dummyport = self.__sockname # Get proper host
    resp = self.sendport(host, port)
    return sock