`

cors 的js

 
阅读更多
获取cors,获得的是一个函数,执行返回一个中间件
(function () {

  'use strict';

  var assign = require('object-assign');
  var vary = require('vary');

  var defaults = {
    origin: '*',
    methods: 'GET,HEAD,PUT,PATCH,POST,DELETE',
    preflightContinue: false,
    optionsSuccessStatus: 204
  };

  function isString(s) {
    return typeof s === 'string' || s instanceof String;
  }

  function isOriginAllowed(origin, allowedOrigin) {
    if (Array.isArray(allowedOrigin)) {
      for (var i = 0; i < allowedOrigin.length; ++i) {
        if (isOriginAllowed(origin, allowedOrigin[i])) {
          return true;
        }
      }
      return false;
    } else if (isString(allowedOrigin)) {
      return origin === allowedOrigin;
    } else if (allowedOrigin instanceof RegExp) {
      return allowedOrigin.test(origin);
    } else {
      return !!allowedOrigin;
    }
  }

  function configureOrigin(options, req) {
    var requestOrigin = req.headers.origin,
      headers = [],
      isAllowed;

    if (!options.origin || options.origin === '*') {
      // allow any origin
      headers.push([{
        key: 'Access-Control-Allow-Origin',
        value: '*'
      }]);
    } else if (isString(options.origin)) {
      // fixed origin
      headers.push([{
        key: 'Access-Control-Allow-Origin',
        value: options.origin
      }]);
      headers.push([{
        key: 'Vary',
        value: 'Origin'
      }]);
    } else {
      isAllowed = isOriginAllowed(requestOrigin, options.origin);
      // reflect origin
      headers.push([{
        key: 'Access-Control-Allow-Origin',
        value: isAllowed ? requestOrigin : false
      }]);
      headers.push([{
        key: 'Vary',
        value: 'Origin'
      }]);
    }

    return headers;
  }

  function configureMethods(options) {
    var methods = options.methods;
    if (methods.join) {
      methods = options.methods.join(','); // .methods is an array, so turn it into a string
    }
    return {
      key: 'Access-Control-Allow-Methods',
      value: methods
    };
  }

  function configureCredentials(options) {
    if (options.credentials === true) {
      return {
        key: 'Access-Control-Allow-Credentials',
        value: 'true'
      };
    }
    return null;
  }

  function configureAllowedHeaders(options, req) {
    var allowedHeaders = options.allowedHeaders || options.headers;
    var headers = [];

    if (!allowedHeaders) {
      allowedHeaders = req.headers['access-control-request-headers']; // .headers wasn't specified, so reflect the request headers
      headers.push([{
        key: 'Vary',
        value: 'Access-Control-Request-Headers'
      }]);
    } else if (allowedHeaders.join) {
      allowedHeaders = allowedHeaders.join(','); // .headers is an array, so turn it into a string
    }
    if (allowedHeaders && allowedHeaders.length) {
      headers.push([{
        key: 'Access-Control-Allow-Headers',
        value: allowedHeaders
      }]);
    }

    return headers;
  }

  function configureExposedHeaders(options) {
    var headers = options.exposedHeaders;
    if (!headers) {
      return null;
    } else if (headers.join) {
      headers = headers.join(','); // .headers is an array, so turn it into a string
    }
    if (headers && headers.length) {
      return {
        key: 'Access-Control-Expose-Headers',
        value: headers
      };
    }
    return null;
  }

  function configureMaxAge(options) {
    var maxAge = (typeof options.maxAge === 'number' || options.maxAge) && options.maxAge.toString()
    if (maxAge && maxAge.length) {
      return {
        key: 'Access-Control-Max-Age',
        value: maxAge
      };
    }
    return null;
  }

  function applyHeaders(headers, res) {
    for (var i = 0, n = headers.length; i < n; i++) {
      var header = headers[i];
      if (header) {
        if (Array.isArray(header)) {
          applyHeaders(header, res);
        } else if (header.key === 'Vary' && header.value) {
          vary(res, header.value);
        } else if (header.value) {
          res.setHeader(header.key, header.value);
        }
      }
    }
  }

  function cors(options, req, res, next) {
    var headers = [],
      method = req.method && req.method.toUpperCase && req.method.toUpperCase();

    if (method === 'OPTIONS') {
      // preflight
      headers.push(configureOrigin(options, req));
      headers.push(configureCredentials(options, req));
      headers.push(configureMethods(options, req));
      headers.push(configureAllowedHeaders(options, req));
      headers.push(configureMaxAge(options, req));
      headers.push(configureExposedHeaders(options, req));
      applyHeaders(headers, res);

      if (options.preflightContinue) {
        next();
      } else {
        // Safari (and potentially other browsers) need content-length 0,
        //   for 204 or they just hang waiting for a body
        res.statusCode = options.optionsSuccessStatus;
        res.setHeader('Content-Length', '0');
        res.end();
      }
    } else {
      // actual response
      headers.push(configureOrigin(options, req));
      headers.push(configureCredentials(options, req));
      headers.push(configureExposedHeaders(options, req));
      applyHeaders(headers, res);
      next();
    }
  }

  function middlewareWrapper(o) {
    // if options are static (either via defaults or custom options passed in), wrap in a function
    var optionsCallback = null;
    if (typeof o === 'function') {
      optionsCallback = o;
    } else {
      optionsCallback = function (req, cb) {
        cb(null, o);
      };
    }

    return function corsMiddleware(req, res, next) {
      optionsCallback(req, function (err, options) {
        if (err) {
          next(err);
        } else {
          var corsOptions = assign({}, defaults, options);
          var originCallback = null;
          if (corsOptions.origin && typeof corsOptions.origin === 'function') {
            originCallback = corsOptions.origin;
          } else if (corsOptions.origin) {
            originCallback = function (origin, cb) {
              cb(null, corsOptions.origin);
            };
          }

          if (originCallback) {
            originCallback(req.headers.origin, function (err2, origin) {
              if (err2 || !origin) {
                next(err2);
              } else {
                corsOptions.origin = origin;
                cors(corsOptions, req, res, next);
              }
            });
          } else {
            next();
          }
        }
      });
    };
  }

  // can pass either an options hash, an options delegate, or nothing
  module.exports = middlewareWrapper;

}());

 

也有这种导出具体对象的~  

 

/**

 * Module exports.

 */

 

module.exports = vary

module.exports.append = append

 

也有这种暴露对象的

 

var server = httpServer.createServer(options);

httpServer = require('../lib/http-server')

 

module.exrpots = {

   a:a

   b:b
}

 

//rule scheme :

module.exports = {

    replaceRequestOption : function(req,option){
        //replace request towards http://www.taobao.com 
        //                     to http://www.taobao.com/about/

        /*
        option scheme:
        {
            hostname : "www.taobao.com"
            port     : 80
            path     : "/"
            method   : "GET"
            headers  : {cookie:""}
        }
        */
       option.headers["User-Agent"]="Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/38.0.2125.111 Safari/537.36"
    },
    printLog : function printLog(content,type){
        //no log any more
    }
};

 

// open jone.yb.com , execute this script in console, then have a tea

$("#JONE-SXGL-DBSQSQCX").click();

function range(start, count) {
    return Array.apply(0, Array(count))
                .map(function (element, index) {
                         return index + start;
                     });
}


(function(db_count, instance_count, page_limit){
  ip_list = ['172.20.132.11', '172.20.132.13', '172.20.132.15', '172.20.132.17''];
  var num = db_count / instance_count;
  setTimeout(function(){
    //step 1, open db auth list
    dbAuthViewListJS.toAddPage();

    console.log('db_count:' + db_count);
    console.log('instance_count:' + instance_count);
    console.log('count:' + (parseInt(db_count / page_limit) + 1));
    $.each(range(1, parseInt(db_count / page_limit) + 1), function(i, v) {
      //step 2, open new auth page
      (function(page){
        setTimeout(function(){
          dbAuthViewListJS.toAddPage();
          //step 3, fill form
          setTimeout(function(){
            // 申请标题
            $("#dbAuthApplyTopic").val('jproxy访问poporder权限申请');

            // 数据库地址
            var end = page_limit*(page+1) > db_count ? db_count : page_limit*(page+1);
            var l = range(page_limit*page, page_limit).map(function(val){
              if(val >= db_count) {
                return undefined;
              }
              var db = {};
              db.ip = ip_list[parseInt(val/num)];
              db.port = '3358';
              db.name = 'poporder_' + val;
              return db;
            });

            $.each(l, function(i, db){
              if (db) {
                $("#dbServerIp").val(db.ip);
                $("#dbPort").val(db.port);
                $("#dbName").val(db.name);
                console.log(db);
                dbAuthAddJS.addDbInfo();
              }
            });

            // 选择应用
            $("#appId option[value='9741']").attr('selected', true);
            dbAuthAddJS.showSelectIpGroupModal();
            setTimeout(function(){
              // 分组/IP选择...
              $("#appGroup option[value='15655']").attr('selected', true);
              dbAuthAddJS.changeGroup();
              setTimeout(function(){
                // IP
                $("#ipUnselected option[value='172.22.70.39']").attr('selected', true);
                $("#ipUnselected option[value='172.22.70.40']").attr('selected', true);
                $("#ipUnselected option[value='172.22.70.41']").attr('selected', true);
                $("#ipUnselected option[value='172.22.71.115']").attr('selected', true);
                $("#ipUnselected option[value='172.22.71.116']").attr('selected', true);
                $("#ipUnselected option[value='172.22.71.117']").attr('selected', true);
                $("#ipUnselected option[value='172.22.71.118']").attr('selected', true);
                dbAuthAddJS.selectIp();
                setTimeout(function(){
                  $("button.close").click();
                  // 参考应用
                  $("#refAppId option[value='9741']").attr('selected', true);
                  dbAuthAddJS.getRefGroup();
                  setTimeout(function(){
                    // 参考组
                    $("#refGroup option[value='15655']").attr('selected', true);
                    dbAuthAddJS.getRefGroupIp();
                    setTimeout(function(){
                      // 参考IP
                      $("#refGroupIp option[deploy-host-ip='172.22.70.39']").attr('selected', true);

                      // 提交
                      dbAuthAddJS.submit();
                      // dbAuthAddJS.toListPage();
                      setTimeout(function(){
                        // 确认结果
                        $('#windowAlertModal').modal('hide');
                      }, 5000);
                    }, 2000);
                  }, 2000);
                }, 1000);
              }, 2000);
            }, 2000);
          }, 2000);
        }, page * 25000);
      })(i);
    });
  }, 3000);
})(1024, 16, 30);

 

分享到:
评论

相关推荐

    跨域cors扩展插件chrome

    总的来说,"跨域cors扩展插件chrome"是HTML5开发,特别是Vue.js开发者在Chrome浏览器上的得力工具,它简化了跨域问题的处理,提高了开发效率。允许CORS的插件是解决开发过程中的跨域限制的有效解决方案,但使用时需...

    SpringMVC CORS跨域测试包

    在给定的压缩包中,可能包含了客户端和服务端的代码示例,客户端可能是使用JavaScript或jQuery发起跨域请求,服务端则展示了如何配置和处理CORS请求。 6. **安全考虑**:虽然CORS提供了一种安全的跨域访问方式,但...

    cors-filter-2.5.jar

    在描述中提到,“解决java web应用跨域问题”,这指的是当JavaScript尝试从一个域名访问另一个域名的资源时,由于浏览器的安全策略,这种请求通常会被阻止。CORS Filter是为了解决这个问题而设计的,它提供了一种...

    vue axios 解决跨域问题CORS

    在开发Web应用时,我们经常会遇到“跨域”(CORS)的问题,特别是在使用Vue.js框架和axios库进行API调用时。Vue.js是一个轻量级的前端框架,而axios则是一个基于Promise的HTTP库,它广泛用于Vue项目中进行数据获取和...

    cors实现的跨域

    跨域资源共享(CORS,Cross-Origin Resource Sharing)是一种机制,允许浏览器在执行JavaScript时,通过HTTP请求访问不同源的资源。这种机制是为了安全考虑,防止恶意脚本从一个站点窃取另一个站点的数据。在传统的...

    cors2.5.jar

    同源策略规定,一个域名下的JavaScript代码只能访问和操作相同源(协议+域名+端口)的资源。而前后端分离的情况下,前端通常运行在HTTP或HTTPS环境下,后端API则部署在不同的服务器上,这就导致了跨域请求的产生,...

    【JavaScript源代码】NodeJS配置CORS实现过程详解.docx

    ### Node.js 配置 CORS 实现过程详解 #### 跨域问题概述 在现代Web开发中,跨域问题是一个常见的安全限制机制,它基于同源策略。同源策略要求一个域下的文档或脚本只能读取或操作来自同一个源的资源。而跨域访问则...

    allow-cors-access-control插件

    JavaScript和ECMAScript是紧密相关的,JavaScript是实现CORS的主要语言。在JavaScript中,我们使用XMLHttpRequest或更现代的Fetch API来发起Ajax请求。在Fetch API中,我们可以设置`mode: 'cors'`来启用CORS,浏览器...

    CORS Scanner工具

    在Web开发中,由于同源策略的限制,JavaScript通常只能访问与包含它的页面同源(协议、域名和端口相同)的资源。然而,为了实现某些功能,如API调用或跨域数据交换,开发者可能需要放宽这些限制。这就是CORS的作用,...

    Spring boot 和Vue开发中CORS跨域问题解决

    本文旨在详细阐述CORS跨域问题的背景、解决方法以及如何在Spring Boot和Vue.js的结合使用场景下处理跨域问题。 ### CORS跨域问题背景 CORS全称是Cross-Origin Resource Sharing,即跨源资源共享。这个概念是W3C的...

    cors跨域包

    跨域是浏览器的一种安全策略,限制了JavaScript只能与同一源(协议+域名+端口)的服务器进行通信。然而,有时我们需要在不同源之间进行交互,比如前端应用从API服务器获取数据,这时就需要用到CORS。 CORS是一种W3C...

    thetransactioncompany.cors.CORSFilter jar包

    在JavaScript中,由于同源策略的限制,通常只能与相同源的服务器进行交互。CORS Filter是解决这个问题的一种方案,尤其在开发API服务时非常常见。 `com.thetransactioncompany.cors.CORSFilter` 是一个开源库,由...

    cors解决ajax跨域

    例如,在Node.js的Express框架中,可以使用`cors`中间件来轻松设置CORS策略: ```javascript const express = require('express'); const cors = require('cors'); const app = express(); app.use(cors()); // ...

    vue+springboot实现项目的CORS跨域请求

    跨域资源共享CORS(Cross-origin Resource Sharing),是W3C的一个标准,允许浏览器向跨源的服务器发起XMLHttpRequest请求,克服ajax请求只能同源使用的限制。关于CORS的详细解读,可参考阮一峰大神的博客:跨域资源...

    baidu_tts_cors_地图搜索_

    因此,"baidu_tts_cors.js"中的"CORS"可能是指开发者在实现地图搜索功能时,通过设置响应头`Access-Control-Allow-Origin`来允许跨域访问百度地图的接口,确保JavaScript代码能在当前页面中正确调用地图服务。...

    cors-filter-2.6和java-property-utils-1.13

    CORS是一种W3C标准,允许浏览器在某些情况下向不同源的服务器发起请求,扩展了JavaScript的同源策略。CORS Filter 2.6是实现这一功能的Java过滤器,它允许开发者配置跨域策略,以控制哪些HTTP请求可以被允许。配置...

    cors-filter-1.7.jar 和 java-property-utils-1.9.jar

    在传统的浏览器安全策略中,JavaScript只能与同源(协议、域名和端口相同)的服务器进行通信,以防止恶意代码窃取或篡改数据。然而,随着Web应用的发展,跨域请求变得越来越常见,比如API接口的调用。CORS为解决这个...

    SRC挖掘经验-cors劫持账户.docx

    在 POC 中,作者使用了 HTML 和 JavaScript 代码来演示 CORS 漏洞挖掘的过程。代码中使用 XMLHttpRequest 对象来发送 GET 请求,并将 withCredentials 设为 true,以便在请求中携带 Cookie 信息。 绕过 CORS 机制的...

    CORS跨域访问框架jra包

    CORS(Cross-Origin Resource Sharing,跨源资源共享)是一种机制,允许Web应用从不同的源获取资源,比如JavaScript通过Ajax请求从另一个域名下获取数据。在Web开发中,由于浏览器的同源策略限制,不同源的HTTP请求...

    tomcat跨域cors相关jar包 cors-filter-1.7.jar和java-property-utils-1.9.jar

    标签中的“cors”和“ajax”表明了这个设置与JavaScript的异步请求有关。AJAX(Asynchronous JavaScript and XML)是通过JavaScript发送XMLHttpRequest对象来实现页面无刷新更新的技术,通常会遇到跨域问题。而...

Global site tag (gtag.js) - Google Analytics