func (self *session) processResponse(res *http.Response) (r *response, err error) {
ret := &response{
code: res.StatusCode,
}
if h, ok := res.Header["Location"]; ok {
ret.redir = h[0]
}
ret.body, err = ioutil.ReadAll(res.Body)
if err != nil {
return ret, err
}
ret.cookies = map[string]string{}
for _, cookie := range res.Cookies() {
ret.cookies[cookie.Name] = cookie.Value
if cookie.Name == "SESSION" {
if self.session == "" {
self.session = cookie.Value
}
}
}
return ret, nil
}
func setupStickySession(responseWriter http.ResponseWriter, response *http.Response,
endpoint *route.Endpoint,
originalEndpointId string,
secureCookies bool,
path string) {
maxAge := 0
// did the endpoint change?
sticky := originalEndpointId != "" && originalEndpointId != endpoint.PrivateInstanceId
for _, v := range response.Cookies() {
if v.Name == StickyCookieKey {
sticky = true
if v.MaxAge < 0 {
maxAge = v.MaxAge
}
break
}
}
if sticky {
cookie := &http.Cookie{
Name: VcapCookieId,
Value: endpoint.PrivateInstanceId,
Path: path,
MaxAge: maxAge,
HttpOnly: true,
Secure: secureCookies,
}
http.SetCookie(responseWriter, cookie)
}
}
func ParseResponse(resp *http.Response, captureContent bool) *Response {
if resp == nil {
return nil
}
statusText := resp.Status
if len(resp.Status) > 4 {
statusText = resp.Status[4:]
}
redirectURL := resp.Header.Get("Location")
harResponse := Response{
Status: resp.StatusCode,
StatusText: statusText,
HttpVersion: resp.Proto,
Cookies: parseCookies(resp.Cookies()),
Headers: parseStringArrMap(resp.Header),
RedirectUrl: redirectURL,
BodySize: resp.ContentLength,
HeadersSize: calcHeaderSize(resp.Header),
}
if captureContent {
parseContent(resp, &harResponse.Content)
}
return &harResponse
}
func (codec *clientCodec) WriteRequest(request *rpc.Request, args interface{}) (err error) {
httpRequest, err := NewRequest(codec.url.String(), request.ServiceMethod, args)
if codec.cookies != nil {
for _, cookie := range codec.cookies.Cookies(codec.url) {
httpRequest.AddCookie(cookie)
}
}
if err != nil {
return err
}
var httpResponse *http.Response
httpResponse, err = codec.httpClient.Do(httpRequest)
if err != nil {
return err
}
if codec.cookies != nil {
codec.cookies.SetCookies(codec.url, httpResponse.Cookies())
}
codec.responses[request.Seq] = httpResponse
codec.ready <- request.Seq
return nil
}
func setUserSession(w http.ResponseWriter, r *http.Request, username string) {
handler.SetCookie(w, r, "_sess", username)
resp := http.Response{Header: w.Header()}
for _, v := range resp.Cookies() {
r.AddCookie(v)
}
}
//Couchdb returns updated AuthSession tokens
func (ca *CookieAuth) updateAuth(resp *http.Response) {
for _, cookie := range resp.Cookies() {
if cookie.Name == "AuthSession" {
ca.UpdatedAuthToken = cookie.Value
}
}
}
func getSessionAndAppPort(url string, rPort uint16, c *C) (string, string, string) {
var client http.Client
var req *http.Request
var resp *http.Response
var err error
var port []byte
uri := fmt.Sprintf("http://%s:%d/sticky", url, rPort)
req, err = http.NewRequest("GET", uri, nil)
resp, err = client.Do(req)
c.Assert(err, IsNil)
port, err = ioutil.ReadAll(resp.Body)
var session string
var path string
for _, cookie := range resp.Cookies() {
if cookie.Name == "__VCAP_ID__" {
session = cookie.Value
path = cookie.Path
}
}
return session, string(port), path
}
func ResponseToJso(o *otto.Object, w *http.Response) {
o.Set("status", w.Status)
o.Set("header", w.Header)
o.Set("cookies", w.Cookies())
o.Set("statusCode", w.StatusCode)
o.Set("proto", w.Proto)
c, _ := ioutil.ReadAll(w.Body)
o.Set("body", string(c))
if w.TLS != nil {
o.Set("tlsServerName", w.TLS.ServerName)
o.Set("tlsNegotiatedProtocol", w.TLS.NegotiatedProtocol)
names := []string{}
ips := []string{}
for _, k := range w.TLS.PeerCertificates {
for _, n := range k.DNSNames {
names = append(names, n)
}
for _, n := range k.IPAddresses {
ips = append(ips, n.String())
}
}
o.Set("tlsDNSNames", names)
o.Set("tlsIPs", ips)
}
}
func (info *Info) SetBasicInfo(url string, response *http.Response) {
info.Url = url
for key, values := range response.Header {
info.RawHeaders[key] = values
}
cookies := response.Cookies()
for _, cookie := range cookies {
info.Cookies[cookie.Name] = cookie
}
u, err := urlLib.Parse(url)
if err != nil {
panic(err)
}
info.Host = u.Host
ips, err := net.LookupHost(u.Host)
if err == nil {
info.Ip = ips
for _, ip := range info.Ip {
hosts, err := net.LookupAddr(ip)
if err == nil {
info.RealHost = hosts
}
}
}
}
//下载文件，并对字符编码做相应的处理
func (this *HttpDownLoader) downloadFile(p *page.Page, req *page.Request) (*page.Page, string) {
var err error
var httpResp *http.Response
var urlStr string
var method string
urlStr = req.GetUrl()
if len(urlStr) == 0 {
logs.GetFirstLogger().Error("url is empty")
p.SetStatus(true, "url is empty")
return p, ""
}
method = req.GetMethod()
if method == "POST" {
httpResp, err = http.Post(req.GetUrl(), "application/x-www-form-urlencoded", strings.NewReader(req.GetPostData()))
} else {
httpResp, err = http.Get(req.GetUrl())
}
if err != nil {
logs.GetFirstLogger().Error("http visit error :" + err.Error())
p.SetStatus(true, err.Error())
}
p.SetHeader(httpResp.Header)
p.SetCookies(httpResp.Cookies())
body, _ := ioutil.ReadAll(httpResp.Body)
bodyStr := string(body)
defer httpResp.Body.Close()
return p, bodyStr
}
func getSessionAndAppPort(url string, rPort uint16) (*http.Cookie, *http.Cookie, string) {
var client http.Client
var req *http.Request
var resp *http.Response
var err error
var port []byte
uri := fmt.Sprintf("http://%s:%d/sticky", url, rPort)
req, err = http.NewRequest("GET", uri, nil)
Expect(err).ToNot(HaveOccurred())
resp, err = client.Do(req)
Expect(err).ToNot(HaveOccurred())
port, err = ioutil.ReadAll(resp.Body)
Expect(err).ToNot(HaveOccurred())
var sessionCookie, vcapCookie *http.Cookie
for _, cookie := range resp.Cookies() {
if cookie.Name == proxy.StickyCookieKey {
sessionCookie = cookie
} else if cookie.Name == proxy.VcapCookieId {
vcapCookie = cookie
}
}
return sessionCookie, vcapCookie, string(port)
}
func generate(credentials string, url string, attempts int) (bool, []int) {
transport := &http.Transport{}
var response *http.Response
//log.Printf("hitting %s", url)
// first try real string without trailing bytes to test a win
req := request(url, credentials)
response, _ = transport.RoundTrip(req)
if response.StatusCode == 200 {
log.Printf("body %v", response.Body)
// return true, nil
}
cookies := response.Cookies()
response.Body.Close()
req = request(url, credentials+" ")
timing := make([]int, 0)
for _, i := range cookies {
req.AddCookie(i)
}
for true {
before := time.Now()
response, err := transport.RoundTrip(req)
duration := time.Since(before)
_ = duration
if err != nil {
log.Printf("Error %v", err)
continue
}
if response.StatusCode == 200 {
return true, nil
}
response.Body.Close()
headertime, _ := strconv.ParseFloat(response.Header.Get("X-Runtime"), 64)
_ = headertime
// log.Printf("X-Runtime = %v, %v, %v", response.Header.Get("X-Runtime"), headertime, int64(headertime*1000000))
timing = append(timing, int(duration.Nanoseconds()))
if len(timing) >= attempts {
break
}
//sleep(200)
}
return false, timing
}
// Gets a cookie with the specified name from the Response
// Returns nil on not finding a suitable cookie
func getRespCookie(resp *http.Response, name string) *http.Cookie {
for _, c := range resp.Cookies() {
if c.Name == name {
return c
}
}
return nil
}
// refresh updates the cookie and expiration used to sign requests from a successful session
// creation API response.
func (s *cookieSigner) refresh(resp *http.Response) error {
if resp.StatusCode != 204 {
return fmt.Errorf("Authentication failed: %s", resp.Status)
}
s.cookies = resp.Cookies()
s.refreshAt = time.Now().Add(time.Duration(2) * time.Hour)
return nil
}
func findResponseCookie(response *http.Response, name string) string {
for _, cookie := range response.Cookies() {
if cookie.Name == name {
return cookie.Value
}
}
return ""
}
// SceneID takes a response of a HTTP request and returns
// a scene ID it received as cookie. It can be used to establish
// session when doing client calls.
func SceneID(resp *http.Response) (string, bool) {
cookies := resp.Cookies()
for _, cookie := range cookies {
if cookie.Name == sceneID {
return cookie.Value, true
}
}
return "", false
}
func getCookie(name string, resp *http.Response) *http.Cookie {
for _, cookie := range resp.Cookies() {
if cookie.Name == name {
return cookie
}
}
return nil
}
func (c *Cache) checkFoomoSessionCookie(res *http.Response) {
sessionCookie := getCookieByName(res.Cookies(), c.foomoSessionCookieName)
if sessionCookie != nil {
if c.foomoSessionCookie == nil || (c.foomoSessionCookie != nil && c.foomoSessionCookie.Value != sessionCookie.Value) {
log.Println("images.CheckFoomoSessionCookie: we have a session cookie", sessionCookie)
c.foomoSessionCookie = sessionCookie
}
}
}
func NewEngine(apple_id, password string) (engine *ICloudEngine, e error) {
engine = new(ICloudEngine)
engine.ClientID = ClientID //strings.ToUpper(util.GenUuid())
cookieJar, _ := cookiejar.New(nil)
client := &http.Client{
Jar: cookieJar,
}
var version *ICloudVersion
if version, e = getICloudVersion(client); e != nil {
return nil, e
}
engine.ReportedVersion = version
info := map[string]string{
"apple_id": apple_id,
"password": password,
"extended_login": "******",
}
data, _ := json.Marshal(info)
var req *http.Request
if req, e = http.NewRequest("POST", loginURL, bytes.NewReader(data)); e != nil {
return nil, e
}
v := url.Values{}
v.Add("clientBuildNumber", version.BuildNumber)
v.Add("clientID", engine.ClientID)
req.URL.RawQuery = v.Encode()
req.Header.Set("Content-Type", "text/plain")
req.Header.Add("Origin", "https://www.icloud.com")
var resp *http.Response
if resp, e = client.Do(req); e != nil {
return nil, e
}
defer resp.Body.Close()
var body []byte
if body, e = ioutil.ReadAll(resp.Body); e != nil {
return nil, e
}
engine.Cookiez = resp.Cookies()
json.Unmarshal(body, engine)
engine.Client = client
return engine, nil
}
func (this *Ajax) saveResponseCookie(response *http.Response) error {
if this.ResponseCookie == nil {
return nil
}
dataCookie, ok1 := this.ResponseCookie.(*[]*http.Cookie)
if ok1 {
*dataCookie = response.Cookies()
} else {
return errors.New("invalid response cookie type " + fmt.Sprintf("%v", this.ResponseCookie))
}
return nil
}
func GetResponseCookies(response *http.Response) (user_id string, token_id string) {
cookies := response.Cookies()
for i := range cookies {
cookie := cookies[i]
if cookie.Name == TOKEN_COOKIE_FIELD_NAME {
token_id = cookie.Value
}
if cookie.Name == USERID_COOKIE_FIELD_NAME {
user_id = cookie.Value
}
}
return
}
// RecordResponse logs an HTTP response, associating it with the previously-logged
// HTTP request with the same ID.
func (l *Logger) RecordResponse(id string, res *http.Response) error {
hres := &Response{
HTTPVersion: res.Proto,
Status: res.StatusCode,
StatusText: http.StatusText(res.StatusCode),
HeadersSize: -1,
BodySize: res.ContentLength,
Headers: headers(proxyutil.ResponseHeader(res).Map()),
Cookies: cookies(res.Cookies()),
}
if res.StatusCode >= 300 && res.StatusCode < 400 {
hres.RedirectURL = res.Header.Get("Location")
}
hres.Content = &Content{
Encoding: "base64",
MimeType: res.Header.Get("Content-Type"),
}
if l.bodyLogging(res) {
mv := messageview.New()
if err := mv.SnapshotResponse(res); err != nil {
return err
}
br, err := mv.BodyReader(messageview.Decode())
if err != nil {
return err
}
body, err := ioutil.ReadAll(br)
if err != nil {
return err
}
hres.Content.Text = body
hres.Content.Size = int64(len(body))
}
l.mu.Lock()
defer l.mu.Unlock()
if e, ok := l.entries[id]; ok {
e.Response = hres
e.Time = time.Since(e.StartedDateTime).Nanoseconds() / 1000000
}
return nil
}
func (this *ClientWxLoginAoModel) callInterface(method string, url string, urlInfo url.Values, result interface{}) {
//提取request的cookie
requestCookies := this.Ctx.Request.Cookies()
//请求url
httpClient := &http.Client{}
var request *http.Request
var resp *http.Response
var err error
url = "http://" + officalHost + url
if method == "get" {
request, err = http.NewRequest("GET", url+"?"+urlInfo.Encode(), nil)
if err != nil {
panic(err)
}
} else {
request, err = http.NewRequest("POST", url, bytes.NewReader([]byte(urlInfo.Encode())))
request.Header.Set("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8")
if err != nil {
panic(err)
}
}
for _, value := range requestCookies {
request.AddCookie(value)
}
resp, err = httpClient.Do(request)
if err != nil {
Throw(1, fmt.Sprintf("调用金象官方系统接口失败:[%s],url为:[%s],参数为:[%v]", err.Error(), url, urlInfo))
}
defer resp.Body.Close()
respString, err := ioutil.ReadAll(resp.Body)
if err != nil {
Throw(1, "获取金象官方系统接口的body失败")
}
if resp.StatusCode != 200 {
Throw(1, fmt.Sprintf("调用金象官方系统接口,状态码为:[%s],url为:[%s],参数为:[%v]", resp.Status, url, urlInfo))
}
err = json.Unmarshal(respString, result)
if err != nil {
Throw(1, "获取金象官方系统接口的json解析失败："+string(respString))
}
//写入cookie
responseCookies := resp.Cookies()
for _, value := range responseCookies {
http.SetCookie(this.Ctx.ResponseWriter, value)
this.Ctx.Request.AddCookie(value)
}
}
func setupStickySession(responseWriter http.ResponseWriter, response *http.Response, endpoint *route.Endpoint) {
for _, v := range response.Cookies() {
if v.Name == StickyCookieKey {
cookie := &http.Cookie{
Name: VcapCookieId,
Value: endpoint.PrivateInstanceId,
Path: "/",
HttpOnly: true,
}
http.SetCookie(responseWriter, cookie)
return
}
}
}
func makeResponse(chain chain, response *http.Response, duration time.Duration) *Response {
var content []byte
var cookies []*http.Cookie
if response != nil {
content = getContent(&chain, response)
cookies = response.Cookies()
} else {
chain.fail("expected non-nil response")
}
return &Response{
chain: chain,
resp: response,
content: content,
cookies: cookies,
time: duration,
}
}
func (s *Session) processOutputHeader(xReq *PxReq, resp *http.Response, w http.ResponseWriter) (err error) {
defer func() {
if e := recover(); e != nil {
err = e.(error)
}
}()
wHeader := w.Header()
for k, array := range resp.Header {
switch k {
case "Set-Cookie":
continue
case "Location":
targetUrl := array[0]
nextUrl := s.processRedirect(targetUrl)
if log.V(1) {
log.Infof("Cook redirection %s -> %s", targetUrl, nextUrl)
}
wHeader.Set(k, nextUrl)
default:
// Alt-Svc, Alternate-Protocol
if strings.HasPrefix(k, "Alt") {
continue
}
for _, v := range array {
wHeader.Add(k, v)
}
}
}
wHeader.Set("Server", "ezgoo")
var alterCookiePath = xReq.nondefault == 0xf
for _, ck := range resp.Cookies() {
if alterCookiePath {
if ck.Domain == NULL || strings.HasPrefix(ck.Domain, ".") {
// prevent ck.path==/!.some-host
ck.Path = fmt.Sprintf("/!%s%s", xReq.url.Host, ck.Path)
} else {
ck.Path = fmt.Sprintf("/!%s%s", ck.Domain, ck.Path)
}
}
if v := cookieString(ck, &s.plainHost, true); v != NULL {
wHeader.Add("Set-Cookie", v)
}
}
return
}
// LoadPage sends HTTP requests and does some minimal parsing of the response. At this point
// this means we extract the cookies. Only handles GET and POST requests as of now.
func (bot *EvernoteAuthBot) LoadPage(uri string, method string, params url.Values) (*http.Response, error) {
var req *http.Request
var resp *http.Response
var err error
/*log.Printf("LoadPage: uri = %s, method = %s, values = %v", uri, method, params)*/
client := &http.Client{
CheckRedirect: redirectPolicy,
}
if method == "GET" {
req, err = http.NewRequest(method, uri+"?"+params.Encode(), nil)
} else if method == "POST" {
req, err = http.NewRequest(method, uri, bytes.NewBufferString(params.Encode()))
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
req.Header.Add("Content-Length", strconv.Itoa(len(params.Encode())))
// TODO: might need to set the content-length here
}
if err != nil {
log.Fatalf("Error trying to set up request: %v", err)
}
// Cookies baby, cookies
for _, cookie := range bot.cookies {
req.AddCookie(cookie)
}
resp, err = client.Do(req)
/*log.Printf("request: %v\n", req)*/
if err != nil {
if e, yes := isBotError(err); yes && e.IsRedirect {
err = nil
}
}
if err == nil {
bot.cookies = resp.Cookies()
}
return resp, err
}
func setPrefDom(xReq *PxReq, w http.ResponseWriter, host string) {
var req *http.Request
var resp *http.Response
var body string
// remove client old cookies
xReq.header.Del("Cookie")
xReq.header.Del("Accept-Encoding")
baseUrl := default_protocol + default_host
ncrUrl := baseUrl + "/?gfe_rd=cr&gws_rd=cr"
req, _ = http.NewRequest("GET", ncrUrl, nil)
req.Header = xReq.header // use client header
resp, body = httpCallEx(req, false)
matches := reSig.FindStringSubmatch(body)
if matches == nil {
log.Infoln(body)
panic("sig not found")
}
sig := matches[0]
setprefUrl := fmt.Sprintf("%s/setprefdomain?prefdom=US&prev=%s&%s", baseUrl, url.QueryEscape(ncrUrl), sig)
req, _ = http.NewRequest("GET", setprefUrl, nil)
req.Header = xReq.header
nid, nidFound := extractNID(resp.Cookies())
if nidFound {
req.Header.Set("Cookie", cookieString(nid, nil, false))
} // else panic ?
resp, _ = httpCallEx(req, true)
nid, nidFound = extractNID(resp.Cookies())
if !nidFound {
dumpHeader(fmt.Sprintf("resp[%s]->%s", resp.Status, req.URL), resp.Header)
panic("nid not found")
} else {
nid.HttpOnly = true
w.Header().Set("Set-Cookie", cookieString(nid, &host, true))
}
w.Header().Set("Location", "/")
w.WriteHeader(302)
}
func (h *RequestHandler) setupStickySession(endpointResponse *http.Response, endpoint *route.Endpoint) {
needSticky := false
for _, v := range endpointResponse.Cookies() {
if v.Name == StickyCookieKey {
needSticky = true
break
}
}
if needSticky && endpoint.PrivateInstanceId != "" {
cookie := &http.Cookie{
Name: VcapCookieId,
Value: endpoint.PrivateInstanceId,
Path: "/",
}
http.SetCookie(h.response, cookie)
}
}
func (c *Cli) saveCookies(resp *http.Response) {
if _, ok := resp.Header["Set-Cookie"]; !ok {
return
}
cookies := resp.Cookies()
for _, cookie := range cookies {
if cookie.Domain == "" {
// if it is host:port then we need to split off port
parts := strings.Split(resp.Request.URL.Host, ":")
host := parts[0]
log.Debugf("Setting DOMAIN to %s for Cookie: %s", host, cookie)
cookie.Domain = host
}
}
// expiry in one week from now
expiry := time.Now().Add(24 * 7 * time.Hour)
for _, cookie := range cookies {
cookie.Expires = expiry
}
if currentCookies := c.loadCookies(); currentCookies != nil {
currentCookiesByName := make(map[string]*http.Cookie)
for _, cookie := range currentCookies {
currentCookiesByName[cookie.Name+cookie.Domain] = cookie
}
for _, cookie := range cookies {
currentCookiesByName[cookie.Name+cookie.Domain] = cookie
}
mergedCookies := make([]*http.Cookie, 0, len(currentCookiesByName))
for _, v := range currentCookiesByName {
mergedCookies = append(mergedCookies, v)
}
jsonWrite(c.cookieFile, mergedCookies)
} else {
mkdir(path.Dir(c.cookieFile))
jsonWrite(c.cookieFile, cookies)
}
}