# ------------------------------------------------------------

# proxy_getter

#   

# Aquire the correct proxy settings of the current machine

#

# Autor: Mihai Bartha, <mihai.bartha@ait.ac.at>       

#

# Copyright 2013-2014 X-Net and AIT Austrian Institute of Technology

# 

# 

#     X-Net Services GmbH

#     Elisabethstrasse 1

#     4020 Linz

#     AUSTRIA

#     https://www.x-net.at

# 

#     AIT Austrian Institute of Technology

#     Donau City Strasse 1

#     1220 Wien

#     AUSTRIA

#     http://www.ait.ac.at

# 

# 

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

# 

#    http://www.apache.org/licenses/LICENSE-2.0

# 

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

# ------------------------------------------------------------

import socket

import os

import httplib

import sys

import _winreg

import re

DNS_WPAD_FILENAME = "wpad.dat"

def check_for_wpad_file(server, path):

    wpad_url = "http://%s/%s"%(server, path)

    print "checking", wpad_url

    try:

        conn = httplib.HTTPConnection(server)

        conn.request("HEAD", "/%s"%path)

        r = conn.getresponse()

        if r.status == 200:

            return wpad_url

    except Exception, e:

        return None

    return None

def get_wpad_server_searchlist():

    #get fully-qualified hostname

    fqhn = socket.getfqdn().split(" ")[0]

    #do we really have a fully-qualified name?

    #if not, linux offers a second possibility

    if fqhn.count(".") == 0 and os.name == 'posix':

        #weird method to get own ip address and fqhn 

        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

        s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)

        s.connect(('<broadcast>', 0))

        my_ip = s.getsockname()[0]

        s.close()

        fqhn = socket.gethostbyaddr(my_ip)[0]

    parts = fqhn.split(".")

    if len(parts) < 3:

        return []

    servers = []

    parts[0] = "wpad"

    servers.append(".".join(parts))

    parts = parts[0:1]+parts[2:]

    #not correct for some suffixes, but everyone does it that way, see wikipedia for details

    while len(parts) >= 3:

        servers.append(".".join(parts))

        parts = parts[0:1]+parts[2:]

    return servers

def search_for_wpad_url():

    #TODO: According to RFC we should check DHCP first, but it isn't used often

    #check most common case first

    wpad_server = "wpad"

    wpad_url = check_for_wpad_file(wpad_server, DNS_WPAD_FILENAME)

    if wpad_url:

        return wpad_url

    #wpad DNS search procedure

    possible_wpad_servers = get_wpad_server_searchlist()

    for server in possible_wpad_servers:

        wpad_url = check_for_wpad_file(server, DNS_WPAD_FILENAME)

        if wpad_url:

            return wpad_url

    #no wpad url found

    return None

def getProxySettings():

    # try to autodetect domain wpad file

    wpad_url = search_for_wpad_url()

    if wpad_url:

        return {'ProxyAutoConfigURL': wpad_url}

    # get Proxy settings from registry      

    aReg = _winreg.ConnectRegistry(None,_winreg.HKEY_CURRENT_USER)

    aKey = _winreg.OpenKey(aReg, r"Software\Microsoft\Windows\CurrentVersion\Internet Settings")

    _, valueCount, _ = _winreg.QueryInfoKey(aKey)

    reg_entries = dict()

    for i in range(valueCount):                                           

        try:

            n,v,_ = _winreg.EnumValue(aKey,i)

            reg_entries[n] = v

        except EnvironmentError:                                               

            break

    _winreg.CloseKey(aKey)

    # return configured WPAD url

    if 'AutoConfigURL' in reg_entries.keys():

        return {'ProxyAutoConfigURL': reg_entries['AutoConfigURL']}

    # return manually configured proxy

    if 'ProxyEnable' in reg_entries.keys() and reg_entries['ProxyEnable'] == 1:

        proxy_search = re.search(r"(?<=http=)(?P<ProxyServer>.*?)(?=;)", reg_entries['ProxyServer'])

        if proxy_search:

            proxies = proxy_search.groupdict()

            if 'ProxyServer' in proxies.keys(): # found http proxy

                return {'ProxyServer': proxies['ProxyServer']}  

        return {'ProxyServer': reg_entries['ProxyServer']}

    return None