Initial commit to move all my solved challenges from "msharran/labs"

repo to here.

Author: msharran

.gitignore

@@ -1,2 +1,5 @@
 .zig-cache/
 zig-out/
+target
+.ruby-lsp
+.DS_Store

curl/cc-go-curl/.gitignore

@@ -0,0 +1 @@
+curl

curl/cc-go-curl/Makefile

@@ -0,0 +1,2 @@
+build:
+	go build

curl/cc-go-curl/Readme.md

@@ -0,0 +1,21 @@
+
+```bash
+projects/cc-go-curl [main●] » ./curl http://eu.httpbin.org/get -v
+* Connecting to eu.httpbin.org (************) port 80
+> GET /get HTTP/1.1
+> Connection: close
+> Host: eu.httpbin.org
+> Accept: */*
+>
+< HTTP/1.1 200 OK
+< Connection:  close
+< Server:  gunicorn/19.9.0
+< Access-Control-Allow-Origin:  *
+< Access-Control-Allow-Credentials:  true
+< Date:  Tue, 04 Jun 2024 12:52:37 GMT
+< Content-Type:  application/json
+< Content-Length:  225
+<
+
+{  "args": {},   "headers": {    "Accept": "*/*",     "Host": "eu.httpbin.org",     "X-Amzn-Trace-Id": "Root=1-665f0e15-54ac009005cb48ec1df2711f"  },   "origin": "************",   "url": "http://eu.httpbin.org/get"}
+```

curl/cc-go-curl/go.mod

@@ -0,0 +1,5 @@
+module curl
+
+go 1.22.1
+
+require github.com/spf13/pflag v1.0.5 // indirect

curl/cc-go-curl/go.sum

@@ -0,0 +1,2 @@
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=

curl/cc-go-curl/internal/http/header.go

@@ -0,0 +1,11 @@
+package http
+
+type Headers map[string]string
+
+func (h Headers) Set(k, v string) {
+	h[k] = v
+}
+
+func (h Headers) Get(k string) string {
+	return h[k]
+}

curl/cc-go-curl/internal/http/http.go

@@ -0,0 +1,51 @@
+package http
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"log"
+	"net"
+)
+
+func Do(r *Request) (*Response, error) {
+	reqb, err := writeWireFormat(r)
+	if err != nil {
+		return nil, fmt.Errorf("writeWireFormat error: %v", err)
+	}
+
+	ip, err := net.ResolveIPAddr("ip", r.URL.Host)
+	if err != nil {
+		log.Fatalf("unable to resolve IP address: %v", err)
+	}
+	log.Printf("* Trying %s...", ip.IP.String())
+
+	conn, err := net.Dial("tcp", r.Addr())
+	if err != nil {
+		return nil, fmt.Errorf("tcp dial error: %v", err)
+	}
+	defer conn.Close()
+
+	log.Printf("* Connected to %s (%s) port %s", r.URL.Host, ip.IP.String(), r.URL.Port)
+	log.Printf("%s", r)
+
+	_, err = io.Copy(conn, reqb)
+	if err != nil {
+		return nil, fmt.Errorf("conn write error: %v", err)
+	}
+
+	respb := new(bytes.Buffer)
+	_, err = io.Copy(respb, conn)
+	if err != nil {
+		return nil, fmt.Errorf("conn read error: %v", err)
+	}
+
+	resp, err := readWireFormat(respb)
+	if err != nil {
+		return nil, fmt.Errorf("readWireFormat error: %v", err)
+	}
+	log.Printf("%s", resp)
+	log.Printf("* Connection #0 to host %s left intact", r.URL.Host)
+
+	return resp, nil
+}

curl/cc-go-curl/internal/http/request.go

@@ -0,0 +1,49 @@
+package http
+
+import (
+	"fmt"
+	"io"
+	"strings"
+)
+
+func NewRequest(method string, url *URL, body io.Writer) *Request {
+	if url == nil {
+		panic("NewRequest: url cannot be nil")
+	}
+
+	r := &Request{
+		URL:    url,
+		Method: method,
+		Body:   nil,
+	}
+	r.Headers = Headers{
+		"Host":       url.Host,
+		"Accept":     "*/*",
+		"Connection": "close",
+	}
+
+	return r
+}
+
+type Request struct {
+	URL     *URL
+	Method  string
+	Headers Headers
+	Body    io.Reader
+}
+
+func (r *Request) Addr() string {
+	return r.URL.Host + ":" + r.URL.PortOrDefault()
+}
+
+func (r *Request) String() string {
+	sb := new(strings.Builder)
+
+	fmt.Fprintf(sb, "> %s %s %s%s", r.Method, r.URL.Path, HttpVersion, CRLF)
+	h := r.Headers
+	for k, v := range h {
+		fmt.Fprintf(sb, "> %s: %s%s", k, v, CRLF)
+	}
+	fmt.Fprintf(sb, ">%s", CRLF)
+	return sb.String()
+}

curl/cc-go-curl/internal/http/response.go

@@ -0,0 +1,35 @@
+package http
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"strings"
+)
+
+type Response struct {
+	HTTPVersion string
+	Headers     Headers
+	Body        io.Reader
+	StatusCode  int
+	StatusText  string
+}
+
+// Response errors
+var (
+	ErrEmptyFirstLine   = errors.New("response: first line is empty")
+	ErrInvalidFirstLine = errors.New("response: first line is invalid")
+	ErrHTTPCodeParse    = errors.New("response: failed to parse status code")
+)
+
+func (r *Response) String() string {
+	sb := new(strings.Builder)
+
+	fmt.Fprintf(sb, "< %s %d %s%s", r.HTTPVersion, r.StatusCode, r.StatusText, CRLF)
+	h := r.Headers
+	for k, v := range h {
+		fmt.Fprintf(sb, "< %s: %s%s", k, v, CRLF)
+	}
+	fmt.Fprintf(sb, "<%s", CRLF)
+	return sb.String()
+}

curl/cc-go-curl/internal/http/url.go

@@ -0,0 +1,54 @@
+package http
+
+import (
+	"errors"
+	"strings"
+)
+
+var (
+	ports = map[string]string{
+		"http":  "80",
+		"https": "443",
+	}
+)
+
+type URL struct {
+	Scheme string
+	Host   string
+	Port   string
+	Path   string
+}
+
+func (u *URL) PortOrDefault() string {
+	if u.Port == "" {
+		return ports[u.Scheme]
+	}
+
+	return u.Port
+}
+
+func ParseURL(url string) (*URL, error) {
+	scheme, rest, ok := strings.Cut(url, "://")
+	if !ok {
+		return nil, errors.New("invalid URL format")
+	}
+
+	if _, ok := ports[scheme]; !ok {
+		return nil, errors.New("unsupported protocol scheme")
+	}
+
+	u := new(URL)
+	u.Scheme = scheme
+
+	addr, rest, _ := strings.Cut(rest, "/")
+	u.Path = "/" + rest
+
+	host, port, ok := strings.Cut(addr, ":")
+	if !ok || port == "" {
+		port = ports[scheme]
+	}
+	u.Host = host
+	u.Port = port
+
+	return u, nil
+}

curl/cc-go-curl/internal/http/wireformat.go

@@ -0,0 +1,114 @@
+package http
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"io"
+	"strings"
+)
+
+const (
+	CRLF        = "\r\n"
+	HttpVersion = "HTTP/1.1"
+)
+
+func readWireFormat(buf *bytes.Buffer) (*Response, error) {
+	// parse http response in wire format to Response struct
+	resp := new(Response)
+	resp.Headers = make(Headers)
+	body := new(bytes.Buffer)
+	resp.Body = body
+
+	scanner := bufio.NewScanner(buf)
+	if !scanner.Scan() && scanner.Err() != nil {
+		return nil, fmt.Errorf("failed to read first line: %v", scanner.Err())
+	}
+
+	firstLine := scanner.Text()
+	_, err := fmt.Sscanf(firstLine, "%s %d %s", &resp.HTTPVersion, &resp.StatusCode, &resp.StatusText)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse first line: %v", err)
+	}
+
+	if resp.HTTPVersion != HttpVersion {
+		return nil, fmt.Errorf("unsupported HTTP version: %s", resp.HTTPVersion)
+	}
+
+	// parse headers
+	for scanner.Scan() {
+		line := scanner.Text()
+
+		if line == "" {
+			break
+		}
+
+		k, v, found := strings.Cut(line, ":")
+		if !found {
+			return nil, fmt.Errorf("malformed header: %s", line)
+		}
+
+		resp.Headers.Set(k, v)
+	}
+
+	// parse body
+	for scanner.Scan() {
+		line := scanner.Text()
+		if line == "" {
+			break
+		}
+
+		_, err := io.WriteString(body, line)
+		if err != nil {
+			return nil, fmt.Errorf("failed to write body: %v", err)
+		}
+	}
+
+	if err := scanner.Err(); err != nil {
+		return nil, fmt.Errorf("scanner error: %v", err)
+	}
+
+	return resp, nil
+}
+
+func writeWireFormat(req *Request) (*bytes.Buffer, error) {
+	buf := new(bytes.Buffer)
+	_, err := fmt.Fprintf(buf, "%s %s %s%s", req.Method, req.URL.Path, HttpVersion, CRLF)
+	if err != nil {
+		return nil, err
+	}
+
+	_, err = fmt.Fprintf(buf, "Host: %s%s", req.URL.Host, CRLF)
+	if err != nil {
+		return nil, err
+	}
+
+	for k, v := range req.Headers {
+		_, err = fmt.Fprintf(buf, "%s: %s%s", k, v, CRLF)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	_, err = fmt.Fprintf(buf, "Connection: close%s", CRLF)
+	if err != nil {
+		return nil, err
+	}
+	_, err = io.WriteString(buf, CRLF)
+	if err != nil {
+		return nil, err
+	}
+
+	if req.Body != nil {
+		_, err = io.Copy(buf, req.Body)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	_, err = io.WriteString(buf, CRLF)
+	if err != nil {
+		return nil, err
+	}
+	return buf, nil
+}