Server IP : 85.214.239.14 / Your IP : 3.145.186.132 Web Server : Apache/2.4.62 (Debian) System : Linux h2886529.stratoserver.net 4.9.0 #1 SMP Tue Jan 9 19:45:01 MSK 2024 x86_64 User : www-data ( 33) PHP Version : 7.4.18 Disable Function : pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,pcntl_unshare, MySQL : OFF | cURL : OFF | WGET : ON | Perl : ON | Python : ON | Sudo : ON | Pkexec : OFF Directory : /usr/share/doc/git/contrib/persistent-https/ |
Upload File : |
// Copyright 2012 Google Inc. All Rights Reserved. // // 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. package main import ( "bufio" "errors" "fmt" "net" "net/url" "os" "os/exec" "strings" "syscall" "time" ) type Client struct { ProxyBin string Args []string insecure bool } func (c *Client) Run() error { if err := c.resolveArgs(); err != nil { return fmt.Errorf("resolveArgs() got error: %v", err) } // Connect to the proxy. uconn, hconn, addr, err := c.connect() if err != nil { return fmt.Errorf("connect() got error: %v", err) } // Keep the unix socket connection open for the duration of the request. defer uconn.Close() // Keep a connection to the HTTP server open, so no other user can // bind on the same address so long as the process is running. defer hconn.Close() // Start the git-remote-http subprocess. cargs := []string{"-c", fmt.Sprintf("http.proxy=%v", addr), "remote-http"} cargs = append(cargs, c.Args...) cmd := exec.Command("git", cargs...) for _, v := range os.Environ() { if !strings.HasPrefix(v, "GIT_PERSISTENT_HTTPS_SECURE=") { cmd.Env = append(cmd.Env, v) } } // Set the GIT_PERSISTENT_HTTPS_SECURE environment variable when // the proxy is using a SSL connection. This allows credential helpers // to identify secure proxy connections, despite being passed an HTTP // scheme. if !c.insecure { cmd.Env = append(cmd.Env, "GIT_PERSISTENT_HTTPS_SECURE=1") } cmd.Stdin = os.Stdin cmd.Stdout = os.Stdout cmd.Stderr = os.Stderr if err := cmd.Run(); err != nil { if eerr, ok := err.(*exec.ExitError); ok { if stat, ok := eerr.ProcessState.Sys().(syscall.WaitStatus); ok && stat.ExitStatus() != 0 { os.Exit(stat.ExitStatus()) } } return fmt.Errorf("git-remote-http subprocess got error: %v", err) } return nil } func (c *Client) connect() (uconn net.Conn, hconn net.Conn, addr string, err error) { uconn, err = DefaultSocket.Dial() if err != nil { if e, ok := err.(*net.OpError); ok && (os.IsNotExist(e.Err) || e.Err == syscall.ECONNREFUSED) { if err = c.startProxy(); err == nil { uconn, err = DefaultSocket.Dial() } } if err != nil { return } } if addr, err = c.readAddr(uconn); err != nil { return } // Open a tcp connection to the proxy. if hconn, err = net.Dial("tcp", addr); err != nil { return } // Verify the address hasn't changed ownership. var addr2 string if addr2, err = c.readAddr(uconn); err != nil { return } else if addr != addr2 { err = fmt.Errorf("address changed after connect. got %q, want %q", addr2, addr) return } return } func (c *Client) readAddr(conn net.Conn) (string, error) { conn.SetDeadline(time.Now().Add(5 * time.Second)) data := make([]byte, 100) n, err := conn.Read(data) if err != nil { return "", fmt.Errorf("error reading unix socket: %v", err) } else if n == 0 { return "", errors.New("empty data response") } conn.Write([]byte{1}) // Ack var addr string if addrs := strings.Split(string(data[:n]), "\n"); len(addrs) != 2 { return "", fmt.Errorf("got %q, wanted 2 addresses", data[:n]) } else if c.insecure { addr = addrs[1] } else { addr = addrs[0] } return addr, nil } func (c *Client) startProxy() error { cmd := exec.Command(c.ProxyBin) cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true} stdout, err := cmd.StdoutPipe() if err != nil { return err } defer stdout.Close() if err := cmd.Start(); err != nil { return err } result := make(chan error) go func() { bytes, _, err := bufio.NewReader(stdout).ReadLine() if line := string(bytes); err == nil && line != "OK" { err = fmt.Errorf("proxy returned %q, want \"OK\"", line) } result <- err }() select { case err := <-result: return err case <-time.After(5 * time.Second): return errors.New("timeout waiting for proxy to start") } panic("not reachable") } func (c *Client) resolveArgs() error { if nargs := len(c.Args); nargs == 0 { return errors.New("remote needed") } else if nargs > 2 { return fmt.Errorf("want at most 2 args, got %v", c.Args) } // Rewrite the url scheme to be http. idx := len(c.Args) - 1 rawurl := c.Args[idx] rurl, err := url.Parse(rawurl) if err != nil { return fmt.Errorf("invalid remote: %v", err) } c.insecure = rurl.Scheme == "persistent-http" rurl.Scheme = "http" c.Args[idx] = rurl.String() if idx != 0 && c.Args[0] == rawurl { c.Args[0] = c.Args[idx] } return nil }