comparing bd437dc577ebac8dc5cc0177c1d331ae06ae2b6e and main on anil.recoil.org/ocaml-fastcgi

+60 -13

bin/fcgi_server.ml

···

       1
       1
        
       open Cmdliner

     

       2
       2
        
       

     

       3
       3
       +
       (* Handler function that processes FastCGI requests *)

     

       4
       4
       +
       let handler ~stdout ~stderr request =

     

       5
       5
       +
         Eio.traceln "Processing request: %a" Fastcgi.Request.pp request;

     

       6
       6
       +
       

     

       7
       7
       +
         (* Get request parameters *)

     

       8
       8
       +
         let params = request.Fastcgi.Request.params in

     

       9
       9
       +
         let method_ = Fastcgi.Record.KV.find_opt "REQUEST_METHOD" params |> Option.value ~default:"GET" in

     

       10
       10
       +
         let uri = Fastcgi.Record.KV.find_opt "REQUEST_URI" params |> Option.value ~default:"/" in

     

       11
       11
       +
         let script_name = Fastcgi.Record.KV.find_opt "SCRIPT_NAME" params |> Option.value ~default:"" in

     

       12
       12
       +
       

     

       13
       13
       +
         (* Log request info *)

     

       14
       14
       +
         Eio.traceln "  Method: %s" method_;

     

       15
       15
       +
         Eio.traceln "  URI: %s" uri;

     

       16
       16
       +
         Eio.traceln "  Script: %s" script_name;

     

       17
       17
       +
       

     

       18
       18
       +
         (* Generate simple HTTP response *)

     

       19
       19
       +
         let response_body =

     

       20
       20
       +
           Printf.sprintf

     

       21
       21
       +
             "<!DOCTYPE html>\n\

     

       22
       22
       +
              <html>\n\

     

       23
       23
       +
              <head><title>FastCGI OCaml Server</title></head>\n\

     

       24
       24
       +
              <body>\n\

     

       25
       25
       +
              <h1>FastCGI OCaml Server</h1>\n\

     

       26
       26
       +
              <p>Request processed successfully!</p>\n\

     

       27
       27
       +
              <ul>\n\

     

       28
       28
       +
              <li>Method: %s</li>\n\

     

       29
       29
       +
              <li>URI: %s</li>\n\

     

       30
       30
       +
              <li>Script: %s</li>\n\

     

       31
       31
       +
              </ul>\n\

     

       32
       32
       +
              <h2>All Parameters:</h2>\n\

     

       33
       33
       +
              <pre>%s</pre>\n\

     

       34
       34
       +
              </body>\n\

     

       35
       35
       +
              </html>\n"

     

       36
       36
       +
             method_ uri script_name

     

       37
       37
       +
             (let params_seq = Fastcgi.Record.KV.to_seq params in

     

       38
       38
       +
              let params_list = List.of_seq params_seq in

     

       39
       39
       +
              String.concat "\n" (List.map (fun (k, v) -> Printf.sprintf "%s = %s" k v) params_list))

     

       40
       40
       +
         in

     

       41
       41
       +
       

     

       42
       42
       +
         (* Write HTTP response using FastCGI STDOUT records *)

     

       43
       43
       +
         let response_headers =

     

       44
       44
       +
           Printf.sprintf

     

       45
       45
       +
             "Status: 200 OK\r\n\

     

       46
       46
       +
              Content-Type: text/html; charset=utf-8\r\n\

     

       47
       47
       +
              Content-Length: %d\r\n\

     

       48
       48
       +
              \r\n"

     

       49
       49
       +
             (String.length response_body)

     

       50
       50
       +
         in

     

       51
       51
       +
         stdout response_headers;

     

       52
       52
       +
         stderr "stderr stuff";

     

       53
       53
       +
         stdout response_body

     

       54
       54
       +
       

     

       3
       55
        
       let run port =

     

       4
       56
        
         Eio_main.run @@ fun env ->

     

       5
       57
        
         Eio.Switch.run @@ fun sw ->

     
···

       7
       59
        
         let addr = `Tcp (Eio.Net.Ipaddr.V4.loopback, port) in

     

       8
       60
        
         let server_socket = Eio.Net.listen net ~backlog:10 ~reuse_addr:true ~sw addr in

     

       9
       61
        
         Eio.traceln "FastCGI server listening on port %d" port;

     

       10
       10
       -
         Eio.Net.run_server server_socket ~on_error:(fun ex -> Eio.traceln "Error: %s" (Printexc.to_string ex))

     

       11
       11
       -
         @@ fun flow addr ->

     

       12
       12
       -
         Eio.traceln "Accepted connection from %a" Eio.Net.Sockaddr.pp addr;

     

       13
       13
       -
         (* Here you would handle the FastCGI protocol, but for simplicity, we just echo a string. *)

     

       14
       14
       -
         let req = Fastcgi.read_request_from_flow ~sw flow in

     

       15
       15
       -
         match req with

     

       16
       16
       -
         | Error msg ->

     

       17
       17
       -
             Eio.traceln "Failed to read request: %s" msg;

     

       18
       18
       -
             Eio.Flow.close flow

     

       19
       19
       -
         | Ok req ->

     

       20
       20
       -
             Eio.traceln "Received request: %a" Fastcgi.Request.pp req;

     

       21
       21
       -
             Eio.Flow.close flow

     

       62
       62
       +
       

     

       63
       63
       +
         (* Run the FastCGI server *)

     

       64
       64
       +
         Fastcgi.run server_socket

     

       65
       65
       +
           ~on_error:(fun ex ->

     

       66
       66
       +
           Eio.traceln "Error: %s" (Printexc.to_string ex);

     

       67
       67
       +
           Eio.traceln "bt: %s" (Printexc.get_backtrace ()))

     

       68
       68
       +
           handler

     

       22
       69
        
       

     

       23
       70
        
       let port =

     

       24
       71
        
         let doc = "Port to listen on" in

     
···

       29
       76
        
         let info = Cmd.info "fcgi-server" ~doc in

     

       30
       77
        
         Cmd.v info Term.(const run $ port)

     

       31
       78
        
       

     

       32
       32
       -
       let () = exit (Cmd.eval cmd)
     

       79
       79
       +
       let () = exit (Cmd.eval cmd)

config/Caddyfile

···

       1
       1
       +
       {

     

       2
       2
       +
         debug

     

       3
       3
       +
       }

     

       4
       4
       +
       

     

       5
       5
       +
       localhost:80 {

     

       6
       6
       +
         php_fastcgi 127.0.0.1:9000

     

       7
       7
       +
       }

+43 -95

lib/fastcgi.ml

···

       3
       3
        
       (** Request-level state machine and application interface *)

     

       4
       4
        
       module Request = Fastcgi_request

     

       5
       5
        
       

     

       6
       6
       -
       (** Request handler function type *)

     

       7
       7
       -
       type handler = Request.t -> 

     

       8
       8
       -
         stdout:Eio.Flow.sink_ty Eio.Resource.t -> 

     

       9
       9
       -
         stderr:Eio.Flow.sink_ty Eio.Resource.t -> 

     

       10
       10
       -
         Request.app_status

     

       11
       11
       -
       

     

       12
       12
       -
       (** [read_request_from_flow ~sw flow] reads a complete FastCGI request from flow.

     

       13
       13
       -
           Processes BEGIN_REQUEST, PARAMS, STDIN, and DATA records until complete.

     

       14
       14
       -
           Returns the populated request context. *)

     

       15
       15
       -
       let read_request_from_flow ~sw:_ flow =

     

       16
       16
       -
         let buf_read = Eio.Buf_read.of_flow flow ~max_size:1000000 in

     

       17
       17
       -
         Request.read_request buf_read

     

       18
       18
       -
       

     

       19
       19
       -
       (** [write_response ~sw request ~stdout ~stderr sink app_status] writes FastCGI response.

     

       20
       20
       -
           Reads from stdout and stderr flows, converts to FastCGI records, and writes to sink.

     

       21
       21
       -
           Automatically handles stream termination and END_REQUEST. *)

     

       22
       22
       -
       let write_response ~sw:_ request ~stdout ~stderr sink app_status =

     

       23
       23
       -
         (* Read stdout content *)

     

       24
       24
       -
         let stdout_buf = Buffer.create 4096 in

     

       25
       25
       -
         Eio.Flow.copy stdout (Eio.Flow.buffer_sink stdout_buf);

     

       26
       26
       -
         let stdout_content = Buffer.contents stdout_buf in

     

       27
       27
       -
         

     

       28
       28
       -
         (* Read stderr content *)

     

       29
       29
       -
         let stderr_buf = Buffer.create 1024 in

     

       30
       30
       -
         Eio.Flow.copy stderr (Eio.Flow.buffer_sink stderr_buf);

     

       31
       31
       -
         let stderr_content = Buffer.contents stderr_buf in

     

       32
       32
       -
         

     

       33
       33
       -
         (* Write response using Buf_write *)

     

       34
       34
       -
         Eio.Buf_write.with_flow sink (fun buf_write ->

     

       35
       35
       -
           Request.write_stdout_records buf_write request.Request.request_id stdout_content;

     

       36
       36
       -
           Request.write_stderr_records buf_write request.Request.request_id stderr_content;

     

       37
       37
       -
           Request.write_end_request buf_write request.Request.request_id app_status Request.Request_complete

     

       38
       38
       -
         )

     

       39
       39
       -
       

     

       40
       40
       -
       (** [process_request ~sw request handler sink] processes complete request.

     

       41
       41
       -
           Calls handler with flows for stdout/stderr output, then writes response to sink. *)

     

       42
       42
       -
       let process_request ~sw request handler sink =

     

       43
       43
       -
         (* Create in-memory flows for stdout and stderr *)

     

       44
       44
       -
         let stdout_buf = Buffer.create 4096 in

     

       45
       45
       -
         let stderr_buf = Buffer.create 1024 in

     

       46
       46
       -
         let stdout_sink = Eio.Flow.buffer_sink stdout_buf in

     

       47
       47
       -
         let stderr_sink = Eio.Flow.buffer_sink stderr_buf in

     

       48
       48
       -
         

     

       49
       49
       -
         (* Call handler *)

     

       50
       50
       -
         let app_status = handler request ~stdout:stdout_sink ~stderr:stderr_sink in

     

       51
       51
       -
         

     

       52
       52
       -
         (* Convert buffers to sources and write response *)

     

       53
       53
       -
         let stdout_source = Eio.Flow.string_source (Buffer.contents stdout_buf) in

     

       54
       54
       -
         let stderr_source = Eio.Flow.string_source (Buffer.contents stderr_buf) in

     

       55
       55
       -
         

     

       56
       56
       -
         write_response ~sw request ~stdout:stdout_source ~stderr:stderr_source sink app_status

     

       57
       57
       -
       

     

       58
       58
       -
       (** [process_request_with_flows ~sw request ~stdout ~stderr sink app_status]

     

       59
       59
       -
           processes request using provided output flows. *)

     

       60
       60
       -
       let process_request_with_flows ~sw request ~stdout ~stderr sink app_status =

     

       61
       61
       -
         write_response ~sw request ~stdout ~stderr sink app_status

     

       62
       62
       -
       

     

       63
       63
       -
       (** {1 Connection Management} *)

     

       64
       64
       -
       

     

       65
       65
       -
       (** [handle_connection ~sw flow handler] handles complete FastCGI connection.

     

       66
       66
       -
           Reads requests from flow, processes them with handler, multiplexes responses.

     

       67
       67
       -
           Continues until connection is closed. *)

     

       68
       68
       -
       let handle_connection ~sw flow handler =

     

       69
       69
       -
         let rec loop () =

     

       70
       70
       -
           try

     

       71
       71
       -
             (* Read next request *)

     

       72
       72
       -
             match read_request_from_flow ~sw flow with

     

       73
       73
       -
             | Error msg ->

     

       74
       74
       -
                 (* Log error and continue or close connection *)

     

       75
       75
       -
                 Printf.eprintf "Error reading request: %s\n%!" msg

     

       76
       76
       -
             | Ok request ->

     

       77
       77
       -
                 (* Process request *)

     

       78
       78
       -
                 let response_buf = Buffer.create 4096 in

     

       79
       79
       -
                 let response_sink = Eio.Flow.buffer_sink response_buf in

     

       80
       80
       -
                 

     

       81
       81
       -
                 process_request ~sw request handler response_sink;

     

       82
       82
       -
                 

     

       83
       83
       -
                 (* Write response to connection *)

     

       84
       84
       -
                 let response_data = Buffer.contents response_buf in

     

       85
       85
       -
                 Eio.Flow.copy (Eio.Flow.string_source response_data) flow;

     

       86
       86
       -
                 

     

       87
       87
       -
                 (* Continue if keep_conn is true *)

     

       88
       88
       -
                 if request.Request.keep_conn then

     

       89
       89
       -
                   loop ()

     

       90
       90
       -
           with

     

       91
       91
       -
           | End_of_file -> () (* Connection closed *)

     

       92
       92
       -
           | exn ->

     

       93
       93
       -
               Printf.eprintf "Connection error: %s\n%!" (Printexc.to_string exn)

     

       6
       6
       +
       (* The lifetime of the handler is that the fiber should return when the

     

       7
       7
       +
          stdout and stderr flows are closed, or an abort request has been received *)

     

       8
       8
       +
       let handle req bw cancel fn =

     

       9
       9
       +
         let cancel () =

     

       10
       10
       +
           Eio.Promise.await cancel;

     

       11
       11
       +
           Eio.traceln "cancelled TODO"

     

       12
       12
       +
         in

     

       13
       13
       +
         let stdout buf = Request.write_stdout_records bw req.Request.request_id buf in

     

       14
       14
       +
         let stderr buf = Request.write_stderr_records bw req.Request.request_id buf in

     

       15
       15
       +
         let run () =

     

       16
       16
       +
           fn ~stdout ~stderr req;

     

       17
       17
       +
           Request.write_end_request bw req.Request.request_id 0 Request.Request_complete

     

       94
       18
        
         in

     

       95
       95
       -
         loop ()

     

       19
       19
       +
         Eio.Fiber.first run cancel

     

       96
       20
        
       

     

       97
       97
       -
       (** [serve ~sw ~backlog ~port handler] creates FastCGI server.

     

       98
       98
       -
           Listens on port, accepts connections, handles each with handler. *)

     

       99
       99
       -
       let serve ~sw:_ ~backlog:_ ~port:_ _handler =

     

       100
       100
       -
         (* This would typically use Eio.Net to create a listening socket *)

     

       101
       101
       -
         (* For now, we'll provide a placeholder implementation *)

     

       102
       102
       -
         failwith "serve: Implementation requires Eio.Net integration"

     

       21
       21
       +
       let run ?max_connections ?additional_domains ?stop ~on_error socket handler =

     

       22
       22
       +
         Eio.Net.run_server socket ?max_connections ?additional_domains ?stop ~on_error

     

       23
       23
       +
           (fun socket peer_address ->

     

       24
       24
       +
             let ids = Hashtbl.create 7 in

     

       25
       25
       +
             Eio.Switch.run @@ fun sw ->

     

       26
       26
       +
             Eio.traceln  "%a: accept connection" Eio.Net.Sockaddr.pp peer_address;

     

       27
       27
       +
             let input = Eio.Buf_read.of_flow ~max_size:max_int socket in

     

       28
       28
       +
             Eio.Buf_write.with_flow socket @@ fun output ->

     

       29
       29
       +
             let cont = ref true in

     

       30
       30
       +
             try while !cont do

     

       31
       31
       +
               match Request.read_request input with

     

       32
       32
       +
               | Error msg ->

     

       33
       33
       +
                   Eio.traceln "%a: failed to read request: %s" Eio.Net.Sockaddr.pp peer_address msg;

     

       34
       34
       +
                   failwith "done";

     

       35
       35
       +
               | Ok req ->

     

       36
       36
       +
                   cont := req.Request.keep_conn;

     

       37
       37
       +
                   Eio.traceln "%a: %b read request %a" Eio.Net.Sockaddr.pp peer_address !cont Request.pp req;

     

       38
       38
       +
                   Eio.Fiber.fork ~sw (fun () ->

     

       39
       39
       +
                     Eio.Switch.run ~name:"req_handler" @@ fun sw ->

     

       40
       40
       +
                     let cancel, canceler = Eio.Promise.create () in

     

       41
       41
       +
                     Hashtbl.add ids req.Request.request_id canceler;

     

       42
       42
       +
                     Eio.Switch.on_release sw (fun () ->

     

       43
       43
       +
                       Hashtbl.remove ids req.Request.request_id

     

       44
       44
       +
                     );

     

       45
       45
       +
                     handle req output cancel handler;

     

       46
       46
       +
                   );

     

       47
       47
       +
             done

     

       48
       48
       +
             with Eio.Io (Eio.Net.E (Connection_reset _), _) ->

     

       49
       49
       +
               Eio.traceln "%a: connection reset" Eio.Net.Sockaddr.pp peer_address

     

       50
       50
       +
           )

+9 -56

lib/fastcgi.mli

···

       14
       14
        
       

     

       15
       15
        
       (** {1 High-level Request Processing} *)

     

       16
       16
        
       

     

       17
       17
       -
       (** Request handler function type *)

     

       18
       18
       -
       type handler = Request.t -> 

     

       19
       19
       -
         stdout:Eio.Flow.sink_ty Eio.Resource.t -> 

     

       20
       20
       -
         stderr:Eio.Flow.sink_ty Eio.Resource.t -> 

     

       21
       21
       -
         Request.app_status

     

       22
       22
       -
       

     

       23
       23
       -
       (** [read_request_from_flow ~sw flow] reads a complete FastCGI request from flow.

     

       24
       24
       -
           Processes BEGIN_REQUEST, PARAMS, STDIN, and DATA records until complete.

     

       25
       25
       -
           Returns the populated request context. *)

     

       26
       26
       -
       val read_request_from_flow : sw:Eio.Switch.t -> 'a Eio.Flow.source -> (Request.t, string) result

     

       27
       27
       -
       

     

       28
       28
       -
       (** [write_response ~sw request ~stdout ~stderr sink app_status] writes FastCGI response.

     

       29
       29
       -
           Reads from stdout and stderr flows, converts to FastCGI records, and writes to sink.

     

       30
       30
       -
           Automatically handles stream termination and END_REQUEST. *)

     

       31
       31
       -
       val write_response : 

     

       32
       32
       -
         sw:Eio.Switch.t ->

     

       33
       33
       -
         Request.t ->

     

       34
       34
       -
         stdout:'a Eio.Flow.source ->

     

       35
       35
       -
         stderr:'a Eio.Flow.source ->

     

       36
       36
       -
         'a Eio.Flow.sink ->

     

       37
       37
       -
         Request.app_status -> unit

     

       38
       38
       -
       

     

       39
       39
       -
       (** [process_request ~sw request handler sink] processes complete request.

     

       40
       40
       -
           Calls handler with flows for stdout/stderr output, then writes response to sink. *)

     

       41
       41
       -
       val process_request :

     

       42
       42
       -
         sw:Eio.Switch.t ->

     

       43
       43
       -
         Request.t ->

     

       44
       44
       -
         handler ->

     

       45
       45
       -
         Eio.Flow.sink_ty Eio.Resource.t -> unit

     

       46
       46
       -
       

     

       47
       47
       -
       (** [process_request_with_flows ~sw request ~stdout ~stderr sink app_status]

     

       48
       48
       -
           processes request using provided output flows. *)

     

       49
       49
       -
       val process_request_with_flows :

     

       50
       50
       -
         sw:Eio.Switch.t ->

     

       51
       51
       -
         Request.t ->

     

       52
       52
       -
         stdout:'a Eio.Flow.source ->

     

       53
       53
       -
         stderr:'a Eio.Flow.source ->

     

       54
       54
       -
         'a Eio.Flow.sink ->

     

       55
       55
       -
         Request.app_status -> unit

     

       56
       56
       -
       

     

       57
       57
       -
       (** {1 Connection Management} *)

     

       58
       58
       -
       

     

       59
       17
        
       (** [handle_connection ~sw flow handler] handles complete FastCGI connection.

     

       60
       18
        
           Reads requests from flow, processes them with handler, multiplexes responses.

     

       61
       19
        
           Continues until connection is closed. *)

     

       62
       62
       -
       val handle_connection :

     

       63
       63
       -
         sw:Eio.Switch.t ->

     

       64
       64
       -
         Eio.Flow.two_way_ty Eio.Resource.t ->

     

       65
       65
       -
         handler ->

     

       66
       66
       -
         unit

     

       67
       67
       -
       

     

       68
       68
       -
       (** [serve ~sw ~backlog ~port handler] creates FastCGI server.

     

       69
       69
       -
           Listens on port, accepts connections, handles each with handler. *)

     

       70
       70
       -
       val serve :

     

       71
       71
       -
         sw:Eio.Switch.t ->

     

       72
       72
       -
         backlog:int ->

     

       73
       73
       -
         port:int ->

     

       74
       74
       -
         handler ->

     

       75
       75
       -
         unit

     

       20
       20
       +
       val run :

     

       21
       21
       +
                  ?max_connections:int ->

     

       22
       22
       +
                  ?additional_domains:[> Eio.Domain_manager.ty ] Eio.Resource.t *

     

       23
       23
       +
                                      int ->

     

       24
       24
       +
                  ?stop:'a Eio__core.Promise.t ->

     

       25
       25
       +
                  on_error:(exn -> unit) ->

     

       26
       26
       +
                  [> [> `Generic ] Eio.Net.listening_socket_ty ] Eio.Resource.t ->

     

       27
       27
       +
                  (stdout:(string -> unit) ->

     

       28
       28
       +
                   stderr:(string -> unit) -> Request.t -> unit) -> 'a

+27 -11

lib/fastcgi_record.ml

···

       77
       77
        
         record_type : record;

     

       78
       78
        
         request_id : request_id;

     

       79
       79
        
         content : string;

     

       80
       80
       +
         offset : int;

     

       81
       81
       +
         length : int;

     

       80
       82
        
       }

     

       81
       83
        
       

     

       82
       84
        
       let pp ?(max_content_len=100) ppf record =

     

       85
       85
       +
         let actual_content = String.sub record.content record.offset record.length in

     

       83
       86
        
         let truncated_content = 

     

       84
       84
       -
           let content = record.content in

     

       85
       85
       -
           let len = String.length content in

     

       86
       86
       -
           if len <= max_content_len then content

     

       87
       87
       -
           else String.sub content 0 max_content_len ^ "..." ^ Printf.sprintf " (%d more bytes)" (len - max_content_len)

     

       87
       87
       +
           let len = String.length actual_content in

     

       88
       88
       +
           if len <= max_content_len then actual_content

     

       89
       89
       +
           else String.sub actual_content 0 max_content_len ^ "..." ^ Printf.sprintf " (%d more bytes)" (len - max_content_len)

     

       88
       90
        
         in

     

       89
       91
        
         Format.fprintf ppf

     

       90
       90
       -
           "@[<2>{ version = %d;@ record_type = %a;@ request_id = %d;@ content = %S }@]"

     

       92
       92
       +
           "@[<2>{ version = %d;@ record_type = %a;@ request_id = %d;@ content = %S;@ offset = %d;@ length = %d }@]"

     

       91
       93
        
           record.version

     

       92
       94
        
           pp_record record.record_type

     

       93
       95
        
           record.request_id

     

       94
       96
        
           truncated_content

     

       97
       97
       +
           record.offset

     

       98
       98
       +
           record.length

     

       95
       99
        
       

     

       96
       100
        
       (* FastCGI constants *)

     

       97
       101
        
       let fcgi_version_1 = 1

     
···

       141
       145
        
           ignore (Eio.Buf_read.take padding_length buf_read)

     

       142
       146
        
         );

     

       143
       147
        
         

     

       144
       144
       -
         let record = { version; record_type; request_id; content } in

     

       148
       148
       +
         let record = { version; record_type; request_id; content; offset = 0; length = String.length content } in

     

       145
       149
        
         Printf.eprintf "[DEBUG] Fastcgi_record.read: Complete record = %s\n%!" 

     

       146
       150
        
           (Format.asprintf "%a" (pp ~max_content_len:50) record);

     

       147
       151
        
         record

     

       148
       152
        
       

     

       149
       153
        
       let write buf_write record =

     

       150
       150
       -
         let content_length = String.length record.content in

     

       154
       154
       +
         let total_content_length = String.length record.content in

     

       155
       155
       +
         let content_offset = record.offset in

     

       156
       156
       +
         let content_length = record.length in

     

       157
       157
       +
         

     

       158
       158
       +
         (* Validate bounds *)

     

       159
       159
       +
         if content_offset < 0 || content_offset > total_content_length then

     

       160
       160
       +
           invalid_arg "Fastcgi_record.write: offset out of bounds";

     

       161
       161
       +
         if content_length < 0 || content_offset + content_length > total_content_length then

     

       162
       162
       +
           invalid_arg "Fastcgi_record.write: length out of bounds";

     

       151
       163
        
         

     

       152
       164
        
         (* Calculate padding for 8-byte alignment *)

     

       153
       165
        
         let padding_length = (8 - (content_length land 7)) land 7 in

     
···

       163
       175
        
         

     

       164
       176
        
         Eio.Buf_write.string buf_write (Bytes.to_string header);

     

       165
       177
        
         

     

       166
       166
       -
         (* Write content *)

     

       178
       178
       +
         (* Write content with offset and length *)

     

       167
       179
        
         if content_length > 0 then

     

       168
       168
       -
           Eio.Buf_write.string buf_write record.content;

     

       180
       180
       +
           Eio.Buf_write.string buf_write record.content ~off:content_offset ~len:content_length;

     

       169
       181
        
         

     

       170
       182
        
         (* Write padding *)

     

       171
       183
        
         if padding_length > 0 then

     

       172
       184
        
           Eio.Buf_write.string buf_write (String.make padding_length '\000')

     

       173
       185
        
       

     

       174
       174
       -
       let create ~version ~record ~request_id ~content =

     

       175
       175
       -
         { version; record_type = record; request_id; content }

     

       186
       186
       +
       let create ?(version=1) ~record ~request_id ~content ?(offset=0) ?length () =

     

       187
       187
       +
         let content_length = match length with

     

       188
       188
       +
           | None -> String.length content - offset

     

       189
       189
       +
           | Some l -> l

     

       190
       190
       +
         in

     

       191
       191
       +
         { version; record_type = record; request_id; content; offset; length = content_length }

     

       176
       192
        
       

     

       177
       193
        
       module KV = struct

     

       178
       194
        
         type t = (string * string) list

+11 -7

lib/fastcgi_record.mli

···

       43
       43
        
           content and optional padding for alignment. *)

     

       44
       44
        
       type t = {

     

       45
       45
        
         version : version;           (** Protocol version (always 1) *)

     

       46
       46
       -
         record_type : record;   (** Type of this record *)

     

       46
       46
       +
         record_type : record;        (** Type of this record *)

     

       47
       47
        
         request_id : request_id;     (** Request identifier *)

     

       48
       48
        
         content : string;            (** Record content data *)

     

       49
       49
       +
         offset : int;                (** Offset within content string (default: 0) *)

     

       50
       50
       +
         length : int;                (** Length to use from content (default: String.length content) *)

     

       49
       51
        
       }

     

       50
       52
        
       

     

       51
       53
        
       (** [pp ?max_content_len ppf record] pretty-prints a FastCGI record.

     
···

       63
       65
        
       (** [write buf_write record] writes a FastCGI record to the output buffer.

     

       64
       66
        
           The record header is automatically constructed from the record fields,

     

       65
       67
        
           and appropriate padding is added to align the record on 8-byte boundaries

     

       66
       66
       -
           for optimal performance. *)

     

       68
       68
       +
           for optimal performance. Uses the record's offset and length fields to

     

       69
       69
       +
           determine which portion of the content to write. *)

     

       67
       70
        
       val write : Eio.Buf_write.t -> t -> unit

     

       68
       71
        
       

     

       69
       69
       -
       (** [create ~version ~record ~request_id ~content] creates a new record

     

       70
       70
       -
           with the specified parameters. The content length is automatically

     

       71
       71
       -
           calculated from the content string. *)

     

       72
       72
       -
       val create : version:version -> record:record -> 

     

       73
       73
       -
                    request_id:request_id -> content:string -> t

     

       72
       72
       +
       (** [create ?version ~record ~request_id ~content ?offset ?length] creates a new record

     

       73
       73
       +
           with the specified parameters. Version defaults to 1 (the only supported version).

     

       74
       74
       +
           If offset and length are not provided, the entire content string is used. *)

     

       75
       75
       +
       val create : ?version:version -> record:record -> 

     

       76
       76
       +
                    request_id:request_id -> content:string -> 

     

       77
       77
       +
                    ?offset:int -> ?length:int -> unit -> t

     

       74
       78
        
       

     

       75
       79
        
       (** {1 Key-Value Pairs} *)

     

       76
       80

+9 -44

lib/fastcgi_request.ml

···

       240
       240
        
         | Overloaded -> 2

     

       241
       241
        
         | Unknown_role -> 3

     

       242
       242
        
       

     

       243
       243
       -
       let stream_records_to_string records =

     

       244
       244
       -
         let buf = Buffer.create 1024 in

     

       245
       245
       -
         List.iter (fun record ->

     

       246
       246
       -
           if not (is_stream_terminator record) then

     

       247
       247
       -
             Buffer.add_string buf record.content

     

       248
       248
       -
         ) records;

     

       249
       249
       -
         Buffer.contents buf

     

       250
       250
       -
       

     

       251
       251
       -
       let string_to_stream_records ~request_id ~record_type content =

     

       252
       252
       -
         let max_chunk = 65535 in (* FastCGI max record content length *)

     

       253
       253
       -
         let len = String.length content in

     

       254
       254
       -
         let records = ref [] in

     

       255
       255
       -
         

     

       256
       256
       -
         let rec chunk_string pos =

     

       257
       257
       -
           if pos >= len then

     

       258
       258
       -
             () (* Empty terminator will be added separately *)

     

       259
       259
       -
           else

     

       260
       260
       -
             let chunk_len = min max_chunk (len - pos) in

     

       261
       261
       -
             let chunk = String.sub content pos chunk_len in

     

       262
       262
       -
             let record = Fastcgi_record.create ~version:1 ~record:record_type ~request_id ~content:chunk in

     

       263
       263
       -
             records := record :: !records;

     

       264
       264
       -
             chunk_string (pos + chunk_len)

     

       265
       265
       -
         in

     

       266
       266
       -
         

     

       267
       267
       -
         chunk_string 0;

     

       268
       268
       -
         

     

       269
       269
       -
         (* Add stream terminator *)

     

       270
       270
       -
         let terminator = Fastcgi_record.create ~version:1 ~record:record_type ~request_id ~content:"" in

     

       271
       271
       -
         records := terminator :: !records;

     

       272
       272
       -
         

     

       273
       273
       -
         List.rev !records

     

       274
       274
       -
       

     

       275
       243
        
       let write_stream_records buf_write request_id record_type content =

     

       276
       244
        
         let max_chunk = 65535 in (* FastCGI max record content length *)

     

       277
       245
        
         let len = String.length content in

     

       278
       278
       -
         

     

       279
       246
        
         let rec chunk_string pos =

     

       280
       280
       -
           if pos >= len then

     

       281
       281
       -
             () (* Empty terminator will be added separately *)

     

       282
       282
       -
           else

     

       247
       247
       +
           if pos < len then begin

     

       283
       248
        
             let chunk_len = min max_chunk (len - pos) in

     

       284
       284
       -
             let chunk = String.sub content pos chunk_len in

     

       285
       285
       -
             let record = Fastcgi_record.create ~version:1 ~record:record_type ~request_id ~content:chunk in

     

       249
       249
       +
             let record = Fastcgi_record.create ~record:record_type ~request_id ~content ~offset:pos ~length:chunk_len () in

     

       286
       250
        
             Fastcgi_record.write buf_write record;

     

       287
       251
        
             chunk_string (pos + chunk_len)

     

       252
       252
       +
           end

     

       288
       253
        
         in

     

       289
       289
       -
         

     

       290
       254
        
         chunk_string 0;

     

       291
       291
       -
         

     

       292
       292
       -
         (* Add stream terminator *)

     

       293
       293
       -
         let terminator = Fastcgi_record.create ~version:1 ~record:record_type ~request_id ~content:"" in

     

       255
       255
       +
         let terminator = Fastcgi_record.create ~record:record_type ~request_id ~content:"" () in

     

       294
       256
        
         Fastcgi_record.write buf_write terminator

     

       295
       257
        
       

     

       296
       258
        
       let write_stdout_records buf_write request_id content =

     

       259
       259
       +
         Printf.eprintf "[DEBUG] write_stdout_records: Writing %d bytes for request_id=%d\n%!" 

     

       260
       260
       +
           (String.length content) request_id;

     

       297
       261
        
         write_stream_records buf_write request_id Stdout content

     

       298
       262
        
       

     

       299
       263
        
       let write_stderr_records buf_write request_id content =

     

       264
       264
       +
         Printf.eprintf "[DEBUG] write_stderr_records: Writing %d bytes for request_id=%d\n%!" 

     

       265
       265
       +
           (String.length content) request_id;

     

       300
       266
        
         write_stream_records buf_write request_id Stderr content

     

       301
       267
        
       

     

       302
       268
        
       let write_end_request buf_write request_id app_status protocol_status =

     
···

       309
       275
        
           Bytes.set_uint8 buf 7 0; (* reserved *)

     

       310
       276
        
           Bytes.to_string buf

     

       311
       277
        
         in

     

       312
       312
       -
         let record = Fastcgi_record.create ~version:1 ~record:End_request ~request_id ~content in

     

       278
       278
       +
         let record = Fastcgi_record.create ~record:End_request ~request_id ~content () in

     

       313
       279
        
         Fastcgi_record.write buf_write record

     

       314
       314
       -

+2 -19

lib/fastcgi_request.mli

···

       25
       25
        
         request_id : Fastcgi_record.request_id;  (** Request identifier *)

     

       26
       26
        
         role : role;                             (** Application role *)

     

       27
       27
        
         keep_conn : bool;                        (** Connection keep-alive flag *)

     

       28
       28
       -
         params : Fastcgi_record.KV.t;          (** Environment parameters *)

     

       28
       28
       +
         params : Fastcgi_record.KV.t;            (** Environment parameters *)

     

       29
       29
        
         stdin_data : string;                     (** Complete STDIN content *)

     

       30
       30
       -
         data_stream : string option;            (** DATA stream for Filter role *)

     

       30
       30
       +
         data_stream : string option;             (** DATA stream for Filter role *)

     

       31
       31
        
       }

     

       32
       32
        
       

     

       33
       33
        
       (** [pp ppf request] pretty-prints a request context *)

     
···

       78
       78
        
       

     

       79
       79
        
       (** [write_end_request buf_write request_id app_status protocol_status] writes END_REQUEST record. *)

     

       80
       80
        
       val write_end_request : Eio.Buf_write.t -> Fastcgi_record.request_id -> app_status -> protocol_status -> unit

     

       81
       81
       -
       

     

       82
       82
       -
       

     

       83
       83
       -
       (** {1 Utilities} *)

     

       84
       84
       -
       

     

       85
       85
       -
       (** [is_stream_terminator record] returns true if record terminates a stream *)

     

       86
       86
       -
       val is_stream_terminator : Fastcgi_record.t -> bool

     

       87
       87
       -
       

     

       88
       88
       -
       (** [stream_records_to_string records] concatenates content from stream records *)

     

       89
       89
       -
       val stream_records_to_string : Fastcgi_record.t list -> string

     

       90
       90
       -
       

     

       91
       91
       -
       (** [string_to_stream_records ~request_id ~record_type content] converts string to stream records *)

     

       92
       92
       -
       val string_to_stream_records : 

     

       93
       93
       -
         request_id:Fastcgi_record.request_id -> 

     

       94
       94
       -
         record_type:Fastcgi_record.record -> 

     

       95
       95
       -
         string -> Fastcgi_record.t list

     

       96
       96
       -
       

     

       97
       97
       -

Compare changes