Esempio n. 1
0
func (p *Proxy) remoteProxyUrl(remoteIP, target string, w http.ResponseWriter, r *http.Request) {
	needCache := false

	fullUrl := target
	if len(r.URL.RawQuery) > 0 {
		fullUrl += "?" + r.URL.RawQuery
	}

	requestUrl := fullUrl
	requestR := r
	contentSource := ""

	var prof *profile.Profile
	if !p.isSelfAddr(remoteIP) {
		prof = p.profileOp.Open(remoteIP)
	}

	rangeInfo := cache.CheckRange(r)
	f := p.lives.Open(remoteIP)
	var u *life.UrlState
	if f != nil {
		u = f.OpenUrl(fullUrl)
	}

	var writeWrap io.Writer = nil

	if p.urlOp != nil {
		delay := p.urlOp.Delay(remoteIP, fullUrl)
		//fmt.Println("url delay: " + delay.String())
		switch delay.Act {
		case profile.DelayActDelayEach:
			if delay.Time > 0 {
				// TODO: create request before sleep, more effective
				d := delay.RandDuration(p.r)
				time.Sleep(d)
				f.Log("proxy " + fullUrl + " delay " + d.String())
			}
			break
		case profile.DelayActDropUntil:
			d := delay.RandDuration(p.r)
			if u != nil && u.DropUntil(d) {
				f.Log("proxy " + fullUrl + " drop " + d.String())
				net.ResetResponse(w)
				return
			}
			break
		case profile.DelayActTimeout:
			if delay.Time > 0 {
				d := delay.RandDuration(p.r)
				time.Sleep(d)
				f.Log("proxy " + fullUrl + " timeout " + d.String())
			} else {
				f.Log("proxy " + fullUrl + " timeout")
			}
			net.ResetResponse(w)
			return
			break
		}

		act := p.urlOp.Action(remoteIP, fullUrl)
		//fmt.Println("url act: " + act.String())
		speed := p.urlOp.Speed(remoteIP, fullUrl)
		bodyDelay := p.urlOp.BodyDelay(remoteIP, fullUrl)

		switch act.Act {
		case profile.UrlActCache:
			needCache = true
		case profile.UrlActStatus:
			status := 502
			if c, err := strconv.Atoi(act.ContentValue); err == nil {
				status = c
			}

			w.WriteHeader(status)
			f.Log("proxy " + fullUrl + " status " + strconv.Itoa(status))
			return
		case profile.UrlActMap:
			requestUrl = act.ContentValue
			requestR = nil
			contentSource = "map " + act.ContentValue
		case profile.UrlActRedirect:
			http.Redirect(w, r, act.ContentValue, 302)
			f.Log("proxy " + fullUrl + " redirect " + act.ContentValue)
			return
		case profile.UrlActRewritten:
			fallthrough
		case profile.UrlActRestore:
			fallthrough
		case profile.UrlActTcpWritten:
			if p.rewriteUrl(fullUrl, w, r, rangeInfo, prof, f, act, speed, bodyDelay) {
				return
			}
		}

		switch bodyDelay.Act {
		case profile.DelayActDelayEach:
			fallthrough
		case profile.DelayActTimeout:
			if writeWrap == nil {
				writeWrap = w
			}

			writeWrap = newDelayWriter(bodyDelay, writeWrap, p.r)
		}

		switch speed.Act {
		case profile.SpeedActConstant:
			if writeWrap == nil {
				writeWrap = w
			}

			writeWrap = newSpeedWriter(speed, writeWrap)
		}
	}

	if needCache && r.Method == "GET" && f != nil {
		c := f.CheckCache(fullUrl, rangeInfo)
		if c != nil && c.Error == nil {
			c.Response(w, writeWrap)
			return
		}
	}

	dont302 := true
	settingContentType := "default"
	if prof != nil {
		dont302 = prof.SettingDont302(fullUrl)
		settingContentType = prof.SettingStringDef(fullUrl, "content-type", settingContentType)
		if prof.SettingSwitch(fullUrl, "disable304") {
			p.disable304FromHeader(requestR.Header)
		}
	}

	httpStart := time.Now()
	resp, postBody, redirection, err := net.NewHttp(requestUrl, requestR, p.parseDomainAsDial(target, remoteIP), dont302)
	if err != nil {
		c := cache.NewUrlCache(fullUrl, r, nil, nil, contentSource, nil, rangeInfo, httpStart, time.Now(), err)
		if f != nil {
			go p.saveContentToCache(fullUrl, f, c, false)
		}

		http.Error(w, "Bad Gateway", 502)
	} else if len(redirection) > 0 {
		http.Redirect(w, r, redirection, 302)
		if f != nil {
			f.Log("proxy " + fullUrl + " redirect " + redirection)
		}
	} else {
		defer resp.Close()
		p.procHeader(resp.Header(), settingContentType)
		content, err := resp.ProxyReturn(w, writeWrap)
		httpEnd := time.Now()
		c := cache.NewUrlCache(fullUrl, r, postBody, resp, contentSource, content, rangeInfo, httpStart, httpEnd, err)
		if f != nil {
			go p.saveContentToCache(fullUrl, f, c, needCache)
		}
	}
}
Esempio n. 2
0
func (p *Proxy) proxyUrl(target string, w http.ResponseWriter, r *http.Request) {
	//fmt.Println("proxy: " + target)
	remoteIP := httpd.RemoteHost(r.RemoteAddr)
	needCache := false

	fullUrl := target
	if len(r.URL.RawQuery) > 0 {
		fullUrl += "?" + r.URL.RawQuery
	}

	requestUrl := fullUrl
	requestR := r
	contentSource := ""

	prof := p.profileOp.Open(remoteIP)

	rangeInfo := cache.CheckRange(r)
	f := p.lives.Open(remoteIP)
	var u *life.UrlState
	if f != nil {
		u = f.OpenUrl(fullUrl)
	}

	if p.urlOp != nil {
		delay := p.urlOp.Delay(remoteIP, fullUrl)
		//fmt.Println("url delay: " + delay.String())
		switch delay.Act {
		case profile.DelayActDelayEach:
			if delay.Time > 0 {
				// TODO: create request before sleep, more effective
				time.Sleep(delay.RandDuration(p.r))
			}
			break
		case profile.DelayActDropUntil:
			if u != nil && u.DropUntil(delay.RandDuration(p.r)) {
				// TODO: more safe method, maybe net.http.Hijacker
				panic("")
			}
			break
		case profile.DelayActTimeout:
			if delay.Time > 0 {
				// TODO: more safe method, maybe net.http.Hijacker
				time.Sleep(delay.RandDuration(p.r))
				panic("")
			}
			break
		}

		act := p.urlOp.Action(remoteIP, fullUrl)
		//fmt.Println("url act: " + act.String())
		switch act.Act {
		case profile.UrlActCache:
			needCache = true
		case profile.UrlActStatus:
			if c, err := strconv.Atoi(act.ContentValue); err == nil {
				w.WriteHeader(c)
			} else {
				w.WriteHeader(502)
			}
			return
		case profile.UrlActMap:
			requestUrl = act.ContentValue
			requestR = nil
			contentSource = "map " + act.ContentValue
		case profile.UrlActRedirect:
			http.Redirect(w, r, act.ContentValue, 302)
			return
		case profile.UrlActRewritten:
			fallthrough
		case profile.UrlActRestore:
			if p.rewriteUrl(fullUrl, w, r, rangeInfo, prof, f, act) {
				return
			}
		}
	}

	if needCache && r.Method == "GET" && f != nil {
		c := f.CheckCache(fullUrl, rangeInfo)
		if c != nil && c.Error == nil {
			c.Response(w)
			return
		}
	}

	httpStart := time.Now()
	resp, postBody, err := net.NewHttp(requestUrl, requestR, p.parseDomainAsDial(target, remoteIP))
	if err != nil {
		c := cache.NewUrlCache(fullUrl, r, nil, nil, contentSource, nil, rangeInfo, httpStart, time.Now(), err)
		if f != nil {
			go p.saveContentToCache(fullUrl, f, c, false)
		}

		http.Error(w, "Bad Gateway", 502)
	} else {
		defer resp.Close()
		content, err := resp.ProxyReturn(w)
		httpEnd := time.Now()
		c := cache.NewUrlCache(fullUrl, r, postBody, resp, contentSource, content, rangeInfo, httpStart, httpEnd, err)
		if f != nil {
			go p.saveContentToCache(fullUrl, f, c, needCache)
		}
	}
}