comparing f9c75292c661c1354cc3d35966b3f307c1ead859 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.Request.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
       +
       }

-3

lib/dune

···

       7
       7
        
         fastcgi_record

     

       8
       8
        
         fastcgi_request

     

       9
       9
        
        )

     

       10
       10
       -
        (modules_without_implementation

     

       11
       11
       -
         fastcgi

     

       12
       12
       -
        )

     

       13
       10
        
       )

+50

lib/fastcgi.ml

···

       1
       1
       +
       module Record = Fastcgi_record

     

       2
       2
       +
       

     

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

     

       4
       4
       +
       module Request = Fastcgi_request

     

       5
       5
       +
       

     

       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

     

       18
       18
       +
         in

     

       19
       19
       +
         Eio.Fiber.first run cancel

     

       20
       20
       +
       

     

       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
       +
           )

+17 -1

lib/fastcgi.mli

···

       3
       3
        
           This library provides a complete implementation of the FastCGI protocol

     

       4
       4
        
           for building high-performance web applications in OCaml. *)

     

       5
       5
        
       

     

       6
       6
       +
       

     

       6
       7
        
       (** {1 Core Protocol Components} *)

     

       7
       8
        
       

     

       8
       9
        
       (** Record-level protocol handling *)

     

       9
       10
        
       module Record = Fastcgi_record

     

       10
       11
        
       

     

       11
       12
        
       (** Request-level state machine and application interface *)

     

       12
       12
       -
       module Request = Fastcgi_request
     

       13
       13
       +
       module Request = Fastcgi_request

     

       14
       14
       +
       

     

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

     

       16
       16
       +
       

     

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

     

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

     

       19
       19
       +
           Continues until connection is closed. *)

     

       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

+38 -156

lib/fastcgi_request.ml

···

       79
       79
        
         String.length record.content = 0

     

       80
       80
        
       

     

       81
       81
        
       

     

       82
       82
       -
       let read_params_from_flow ~sw:_ buf_read =

     

       82
       82
       +
       let read_params buf_read =

     

       83
       83
        
         Printf.eprintf "[DEBUG] read_params_from_flow: Starting\n%!";

     

       84
       84
        
         let params = ref KV.empty in

     

       85
       85
        
         let rec loop () =

     
···

       114
       114
        
         in

     

       115
       115
        
         loop ()

     

       116
       116
        
       

     

       117
       117
       -
       let read_stdin_from_flow ~sw:_ buf_read =

     

       117
       117
       +
       let read_stdin buf_read =

     

       118
       118
        
         Printf.eprintf "[DEBUG] read_stdin_from_flow: Starting\n%!";

     

       119
       119
        
         let data = Buffer.create 1024 in

     

       120
       120
        
         let rec loop () =

     
···

       148
       148
        
         loop ()

     

       149
       149
        
       

     

       150
       150
        
       (** Read DATA stream for Filter role *)

     

       151
       151
       -
       let read_data_from_flow buf_read =

     

       151
       151
       +
       let read_data buf_read =

     

       152
       152
        
         let data_buf = Buffer.create 1024 in

     

       153
       153
        
         let rec read_data () =

     

       154
       154
        
           try

     
···

       168
       168
        
         read_data ()

     

       169
       169
        
       

     

       170
       170
        
       (** Read request streams based on role *)

     

       171
       171
       -
       let read_request_streams ~sw request buf_read =

     

       171
       171
       +
       let read_request_streams request buf_read =

     

       172
       172
        
         Printf.eprintf "[DEBUG] read_request_streams: Processing role=%s\n%!" 

     

       173
       173
        
           (Format.asprintf "%a" pp_role request.role);

     

       174
       174
        
         match request.role with

     
···

       177
       177
        
             Ok request

     

       178
       178
        
         | Responder ->

     

       179
       179
        
             Printf.eprintf "[DEBUG] read_request_streams: Responder role, reading STDIN\n%!";

     

       180
       180
       -
             let* stdin_data = read_stdin_from_flow ~sw buf_read in

     

       180
       180
       +
             let* stdin_data = read_stdin buf_read in

     

       181
       181
        
             Printf.eprintf "[DEBUG] read_request_streams: Got STDIN data, %d bytes\n%!" (String.length stdin_data);

     

       182
       182
        
             Ok { request with stdin_data }

     

       183
       183
        
         | Filter ->

     

       184
       184
        
             Printf.eprintf "[DEBUG] read_request_streams: Filter role, reading STDIN and DATA\n%!";

     

       185
       185
       -
             let* stdin_data = read_stdin_from_flow ~sw buf_read in

     

       185
       185
       +
             let* stdin_data = read_stdin buf_read in

     

       186
       186
        
             Printf.eprintf "[DEBUG] read_request_streams: Got STDIN data, %d bytes\n%!" (String.length stdin_data);

     

       187
       187
        
             let request = { request with stdin_data } in

     

       188
       188
       -
             let* data = read_data_from_flow buf_read in

     

       188
       188
       +
             let* data = read_data buf_read in

     

       189
       189
        
             Printf.eprintf "[DEBUG] read_request_streams: Got DATA stream, %d bytes\n%!" (String.length data);

     

       190
       190
        
             Ok { request with data_stream = Some data }

     

       191
       191
        
       

     

       192
       192
       -
       let read_request_from_flow ~sw flow =

     

       193
       193
       -
         Printf.eprintf "[DEBUG] read_request_from_flow: Starting\n%!";

     

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

     

       192
       192
       +
       let read_request buf_read =

     

       193
       193
       +
         Printf.eprintf "[DEBUG] read_request: Starting\n%!";

     

       195
       194
        
         try

     

       196
       195
        
           (* Read BEGIN_REQUEST *)

     

       197
       197
       -
           Printf.eprintf "[DEBUG] read_request_from_flow: Reading BEGIN_REQUEST record\n%!";

     

       196
       196
       +
           Printf.eprintf "[DEBUG] read_request: Reading BEGIN_REQUEST record\n%!";

     

       198
       197
        
           let begin_record = Fastcgi_record.read buf_read in

     

       199
       199
       -
           Printf.eprintf "[DEBUG] read_request_from_flow: Got BEGIN_REQUEST record: %s\n%!"

     

       198
       198
       +
           Printf.eprintf "[DEBUG] read_request: Got BEGIN_REQUEST record: %s\n%!"

     

       200
       199
        
             (Format.asprintf "%a" (Fastcgi_record.pp ~max_content_len:50) begin_record);

     

       201
       200
        
           let* request = create begin_record in

     

       202
       202
       -
           Printf.eprintf "[DEBUG] read_request_from_flow: Created request with role=%s, id=%d\n%!"

     

       201
       201
       +
           Printf.eprintf "[DEBUG] read_request: Created request with role=%s, id=%d\n%!"

     

       203
       202
        
             (Format.asprintf "%a" pp_role request.role) request.request_id;

     

       204
       203
        
           (* Read PARAMS stream *)

     

       205
       205
       -
           Printf.eprintf "[DEBUG] read_request_from_flow: Reading PARAMS stream\n%!";

     

       206
       206
       -
           let* params = read_params_from_flow ~sw buf_read in

     

       207
       207
       -
           Printf.eprintf "[DEBUG] read_request_from_flow: Got %d params\n%!" (Fastcgi_record.KV.cardinal params);

     

       204
       204
       +
           Printf.eprintf "[DEBUG] read_request: Reading PARAMS stream\n%!";

     

       205
       205
       +
           let* params = read_params buf_read in

     

       206
       206
       +
           Printf.eprintf "[DEBUG] read_request: Got %d params\n%!" (Fastcgi_record.KV.cardinal params);

     

       208
       207
        
           let request = { request with params } in

     

       209
       208
        
           (* Read remaining streams based on role *)

     

       210
       210
       -
           Printf.eprintf "[DEBUG] read_request_from_flow: Reading streams for role=%s\n%!"

     

       209
       209
       +
           Printf.eprintf "[DEBUG] read_request: Reading streams for role=%s\n%!"

     

       211
       210
        
             (Format.asprintf "%a" pp_role request.role);

     

       212
       212
       -
           let result = read_request_streams ~sw request buf_read in

     

       213
       213
       -
           Printf.eprintf "[DEBUG] read_request_from_flow: Finished reading request\n%!";

     

       211
       211
       +
           let result = read_request_streams request buf_read in

     

       212
       212
       +
           Printf.eprintf "[DEBUG] read_request: Finished reading request\n%!";

     

       214
       213
        
           result

     

       215
       214
        
         with

     

       216
       215
        
         | End_of_file -> 

     

       217
       217
       -
             Printf.eprintf "[DEBUG] read_request_from_flow: Hit End_of_file\n%!";

     

       216
       216
       +
             Printf.eprintf "[DEBUG] read_request: Hit End_of_file\n%!";

     

       218
       217
        
             Error "Unexpected end of stream"

     

       219
       218
        
         | exn -> 

     

       220
       220
       -
             Printf.eprintf "[DEBUG] read_request_from_flow: Exception: %s\n%!" (Printexc.to_string exn);

     

       219
       219
       +
             Printf.eprintf "[DEBUG] read_request: Exception: %s\n%!" (Printexc.to_string exn);

     

       221
       220
        
             Error (Printf.sprintf "Error reading request: %s" (Printexc.to_string exn))

     

       222
       221
        
       

     

       223
       222
        
       (** {1 Response Generation} *)

     
···

       241
       240
        
         | Overloaded -> 2

     

       242
       241
        
         | Unknown_role -> 3

     

       243
       242
        
       

     

       244
       244
       -
       let stream_records_to_string records =

     

       245
       245
       -
         let buf = Buffer.create 1024 in

     

       246
       246
       -
         List.iter (fun record ->

     

       247
       247
       -
           if not (is_stream_terminator record) then

     

       248
       248
       -
             Buffer.add_string buf record.content

     

       249
       249
       -
         ) records;

     

       250
       250
       -
         Buffer.contents buf

     

       251
       251
       -
       

     

       252
       252
       -
       let string_to_stream_records ~request_id ~record_type content =

     

       243
       243
       +
       let write_stream_records buf_write request_id record_type content =

     

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

     

       254
       245
        
         let len = String.length content in

     

       255
       255
       -
         let records = ref [] in

     

       256
       256
       -
         

     

       257
       246
        
         let rec chunk_string pos =

     

       258
       258
       -
           if pos >= len then

     

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

     

       260
       260
       -
           else

     

       247
       247
       +
           if pos < len then begin

     

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

     

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

     

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

     

       264
       264
       -
             records := record :: !records;

     

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

     

       250
       250
       +
             Fastcgi_record.write buf_write record;

     

       265
       251
        
             chunk_string (pos + chunk_len)

     

       252
       252
       +
           end

     

       266
       253
        
         in

     

       267
       267
       -
         

     

       268
       254
        
         chunk_string 0;

     

       269
       269
       -
         

     

       270
       270
       -
         (* Add stream terminator *)

     

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

     

       272
       272
       -
         records := terminator :: !records;

     

       273
       273
       -
         

     

       274
       274
       -
         List.rev !records

     

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

     

       256
       256
       +
         Fastcgi_record.write buf_write terminator

     

       275
       257
        
       

     

       276
       276
       -
       let flow_to_stream_records ~sw:_ ~request_id ~record_type flow =

     

       277
       277
       -
         (* Read entire flow content *)

     

       278
       278
       -
         let buf = Buffer.create 4096 in

     

       279
       279
       -
         Eio.Flow.copy flow (Eio.Flow.buffer_sink buf);

     

       280
       280
       -
         let content = Buffer.contents buf in

     

       281
       281
       -
         string_to_stream_records ~request_id ~record_type content

     

       258
       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;

     

       261
       261
       +
         write_stream_records buf_write request_id Stdout content

     

       282
       262
        
       

     

       283
       283
       -
       let write_stream_records records sink =

     

       284
       284
       -
         (* Create a function to serialize a single record to a string *)

     

       285
       285
       -
         let serialize_record record =

     

       286
       286
       -
           let buf = Buffer.create 512 in

     

       287
       287
       -
           let buf_sink = Eio.Flow.buffer_sink buf in

     

       288
       288
       -
           Eio.Buf_write.with_flow buf_sink (fun buf_write ->

     

       289
       289
       -
             Fastcgi_record.write buf_write record

     

       290
       290
       -
           );

     

       291
       291
       -
           Buffer.contents buf

     

       292
       292
       -
         in

     

       293
       293
       -
         

     

       294
       294
       -
         (* Serialize all records and write to sink *)

     

       295
       295
       -
         List.iter (fun record ->

     

       296
       296
       -
           let serialized = serialize_record record in

     

       297
       297
       -
           Eio.Flow.copy_string serialized sink

     

       298
       298
       -
         ) records

     

       263
       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;

     

       266
       266
       +
         write_stream_records buf_write request_id Stderr content

     

       299
       267
        
       

     

       300
       300
       -
       let make_end_request ~request_id ~app_status ~protocol_status =

     

       268
       268
       +
       let write_end_request buf_write request_id app_status protocol_status =

     

       301
       269
        
         let content = 

     

       302
       270
        
           let buf = Bytes.create 8 in

     

       303
       271
        
           Bytes.set_int32_be buf 0 (Int32.of_int app_status);

     
···

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

     

       308
       276
        
           Bytes.to_string buf

     

       309
       277
        
         in

     

       310
       310
       -
         Fastcgi_record.create ~version:1 ~record:End_request ~request_id ~content

     

       311
       311
       -
       

     

       312
       312
       -
       let write_response ~sw request ~stdout ~stderr sink app_status =

     

       313
       313
       -
         (* Convert stdout flow to STDOUT records *)

     

       314
       314
       -
         let stdout_records = flow_to_stream_records ~sw ~request_id:request.request_id ~record_type:Stdout stdout in

     

       315
       315
       -
         

     

       316
       316
       -
         (* Convert stderr flow to STDERR records *)

     

       317
       317
       -
         let stderr_records = flow_to_stream_records ~sw ~request_id:request.request_id ~record_type:Stderr stderr in

     

       318
       318
       -
         

     

       319
       319
       -
         (* Create END_REQUEST record *)

     

       320
       320
       -
         let end_record = make_end_request ~request_id:request.request_id ~app_status ~protocol_status:Request_complete in

     

       321
       321
       -
         

     

       322
       322
       -
         (* Write all records *)

     

       323
       323
       -
         let all_records = stdout_records @ stderr_records @ [end_record] in

     

       324
       324
       -
         write_stream_records all_records sink

     

       325
       325
       -
       

     

       326
       326
       -
       let write_error_response request sink proto_status =

     

       327
       327
       -
         let end_record = make_end_request ~request_id:request.request_id ~app_status:1 ~protocol_status:proto_status in

     

       328
       328
       -
         write_stream_records [end_record] sink

     

       329
       329
       -
       

     

       330
       330
       -
       let write_abort_response request sink =

     

       331
       331
       -
         let end_record = make_end_request ~request_id:request.request_id ~app_status:0 ~protocol_status:Request_complete in

     

       332
       332
       -
         write_stream_records [end_record] sink

     

       333
       333
       -
       

     

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

     

       335
       335
       -
       

     

       336
       336
       -
       type handler = t -> 

     

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

     

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

     

       339
       339
       -
         app_status

     

       340
       340
       -
       

     

       341
       341
       -
       let process_request ~sw request handler sink =

     

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

     

       343
       343
       -
         let stdout_buf = Buffer.create 4096 in

     

       344
       344
       -
         let stderr_buf = Buffer.create 1024 in

     

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

     

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

     

       347
       347
       -
         

     

       348
       348
       -
         (* Call handler *)

     

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

     

       350
       350
       -
         

     

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

     

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

     

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

     

       354
       354
       -
         

     

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

     

       356
       356
       -
       

     

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

     

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

     

       359
       359
       -
       

     

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

     

       361
       361
       -
       

     

       362
       362
       -
       let handle_connection ~sw flow handler =

     

       363
       363
       -
         let _buf_read = Eio.Buf_read.of_flow flow ~max_size:1000000 in

     

       364
       364
       -
         let _buf_write = Eio.Buf_write.create 4096 in

     

       365
       365
       -
         

     

       366
       366
       -
         let rec loop () =

     

       367
       367
       -
           try

     

       368
       368
       -
             (* Read next request *)

     

       369
       369
       -
             match read_request_from_flow ~sw flow with

     

       370
       370
       -
             | Error msg ->

     

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

     

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

     

       373
       373
       -
             | Ok request ->

     

       374
       374
       -
                 (* Process request *)

     

       375
       375
       -
                 let response_buf = Buffer.create 4096 in

     

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

     

       377
       377
       -
                 

     

       378
       378
       -
                 process_request ~sw request handler response_sink;

     

       379
       379
       -
                 

     

       380
       380
       -
                 (* Write response to connection *)

     

       381
       381
       -
                 let response_data = Buffer.contents response_buf in

     

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

     

       383
       383
       -
                 

     

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

     

       385
       385
       -
                 if request.keep_conn then

     

       386
       386
       -
                   loop ()

     

       387
       387
       -
           with

     

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

     

       389
       389
       -
           | exn ->

     

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

     

       391
       391
       -
         in

     

       392
       392
       -
         loop ()

     

       393
       393
       -
       

     

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

     

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

     

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

     

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

     

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

     

       279
       279
       +
         Fastcgi_record.write buf_write record

+23 -123

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 *)

     
···

       38
       38
        
       

     

       39
       39
        
       (** {1 Stream Processing} *)

     

       40
       40
        
       

     

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

     

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

     

       43
       43
       -
           Returns the populated request context. *)

     

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

     

       45
       45
       -
       

     

       46
       46
       -
       (** [read_params_from_flow ~sw buf_read] reads PARAMS stream from buf_read until empty record.

     

       41
       41
       +
       (** [read_params buf_read] reads PARAMS stream from buf_read until empty record.

     

       47
       42
        
           Returns the accumulated parameters. *)

     

       48
       48
       -
       val read_params_from_flow : sw:Eio.Switch.t -> Eio.Buf_read.t -> (Fastcgi_record.KV.t, string) result

     

       43
       43
       +
       val read_params : Eio.Buf_read.t -> (Fastcgi_record.KV.t, string) result

     

       49
       44
        
       

     

       50
       50
       -
       (** [read_stdin_from_flow ~sw buf_read] reads STDIN stream from buf_read until empty record.

     

       45
       45
       +
       (** [read_stdin buf_read] reads STDIN stream from buf_read until empty record.

     

       51
       46
        
           Returns the accumulated data. *)

     

       52
       52
       -
       val read_stdin_from_flow : sw:Eio.Switch.t -> Eio.Buf_read.t -> (string, string) result

     

       47
       47
       +
       val read_stdin : Eio.Buf_read.t -> (string, string) result

     

       48
       48
       +
       

     

       49
       49
       +
       (** [read_data buf_read] reads DATA stream from buf_read until empty record.

     

       50
       50
       +
           Returns the accumulated data for Filter role. *)

     

       51
       51
       +
       val read_data : Eio.Buf_read.t -> (string, string) result

     

       52
       52
       +
       

     

       53
       53
       +
       (** [read_request buf_read] reads a complete FastCGI request from buf_read.

     

       54
       54
       +
           Processes BEGIN_REQUEST, PARAMS, STDIN, and DATA records until complete.

     

       55
       55
       +
           Returns the populated request context. *)

     

       56
       56
       +
       val read_request : Eio.Buf_read.t -> (t, string) result

     

       53
       57
        
       

     

       54
       58
        
       (** {1 Response Generation} *)

     

       55
       59
        
       

     
···

       64
       68
        
       (** [pp_protocol_status ppf status] pretty-prints protocol status *)

     

       65
       69
        
       val pp_protocol_status : Format.formatter -> protocol_status -> unit

     

       66
       70
        
       

     

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

     

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

     

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

     

       70
       70
       -
       val write_response : 

     

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

     

       72
       72
       -
         t ->

     

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

     

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

     

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

     

       76
       76
       -
         app_status -> unit

     

       77
       77
       -
       

     

       78
       78
       -
       (** [write_error_response request sink proto_status] writes error END_REQUEST record *)

     

       79
       79
       -
       val write_error_response : t -> 'a Eio.Flow.sink -> protocol_status -> unit

     

       80
       80
       -
       

     

       81
       81
       -
       (** [write_abort_response request sink] writes END_REQUEST for aborted request *)

     

       82
       82
       -
       val write_abort_response : t -> 'a Eio.Flow.sink -> unit

     

       83
       83
       -
       

     

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

     

       85
       85
       -
       

     

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

     

       87
       87
       -
       type handler = t -> 

     

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

     

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

     

       90
       90
       -
         app_status

     

       91
       91
       -
       

     

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

     

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

     

       94
       94
       -
       val process_request :

     

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

     

       96
       96
       -
         t ->

     

       97
       97
       -
         handler ->

     

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

     

       99
       99
       -
       

     

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

     

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

     

       102
       102
       -
       val process_request_with_flows :

     

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

     

       104
       104
       -
         t ->

     

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

     

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

     

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

     

       108
       108
       -
         app_status -> unit

     

       109
       109
       -
       

     

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

     

       111
       111
       -
       

     

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

     

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

     

       114
       114
       -
           Continues until connection is closed. *)

     

       115
       115
       -
       val handle_connection :

     

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

     

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

     

       118
       118
       -
         handler ->

     

       119
       119
       -
         unit

     

       71
       71
       +
       (** [write_stdout_records buf_write request_id content] writes STDOUT stream records.

     

       72
       72
       +
           Splits content into chunks and writes with terminator. *)

     

       73
       73
       +
       val write_stdout_records : Eio.Buf_write.t -> Fastcgi_record.request_id -> string -> unit

     

       120
       74
        
       

     

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

     

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

     

       123
       123
       -
       val serve :

     

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

     

       125
       125
       -
         backlog:int ->

     

       126
       126
       -
         port:int ->

     

       127
       127
       -
         handler ->

     

       128
       128
       -
         unit

     

       129
       129
       -
       

     

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

     

       131
       131
       -
       

     

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

     

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

     

       134
       134
       -
       

     

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

     

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

     

       75
       75
       +
       (** [write_stderr_records buf_write request_id content] writes STDERR stream records.

     

       76
       76
       +
           Splits content into chunks and writes with terminator. *)

     

       77
       77
       +
       val write_stderr_records : Eio.Buf_write.t -> Fastcgi_record.request_id -> string -> unit

     

       137
       78
        
       

     

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

     

       139
       139
       -
       val string_to_stream_records : 

     

       140
       140
       -
         request_id:Fastcgi_record.request_id -> 

     

       141
       141
       -
         record_type:Fastcgi_record.record -> 

     

       142
       142
       -
         string -> Fastcgi_record.t list

     

       143
       143
       -
       

     

       144
       144
       -
       (** [flow_to_stream_records ~sw ~request_id ~record_type flow] converts flow to stream records *)

     

       145
       145
       -
       val flow_to_stream_records :

     

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

     

       147
       147
       -
         request_id:Fastcgi_record.request_id ->

     

       148
       148
       -
         record_type:Fastcgi_record.record ->

     

       149
       149
       -
         'a Eio.Flow.source -> Fastcgi_record.t list

     

       150
       150
       -
       

     

       151
       151
       -
       (** [write_stream_records records sink] writes stream records to flow *)

     

       152
       152
       -
       val write_stream_records : Fastcgi_record.t list -> 'a Eio.Flow.sink -> unit

     

       153
       153
       -
       

     

       154
       154
       -
       (** {1 Example Usage} *)

     

       155
       155
       -
       

     

       156
       156
       -
       (** {2 Simple Handler}

     

       157
       157
       -
       {[

     

       158
       158
       -
       let my_handler request ~stdout ~stderr =

     

       159
       159
       -
         (* Write CGI headers *)

     

       160
       160
       -
         Eio.Flow.copy_string "Content-Type: text/html\r\n\r\n" stdout;

     

       161
       161
       -
         

     

       162
       162
       -
         (* Generate response based on request.params *)

     

       163
       163
       -
         let method_ = Fastcgi_record.KV.find "REQUEST_METHOD" request.params in

     

       164
       164
       -
         Eio.Flow.copy_string ("<h1>Hello from " ^ method_ ^ "</h1>") stdout;

     

       165
       165
       -
         

     

       166
       166
       -
         (* Optional error logging *)

     

       167
       167
       -
         if method_ = "POST" then

     

       168
       168
       -
           Eio.Flow.copy_string "Processing POST data\n" stderr;

     

       169
       169
       -
         

     

       170
       170
       -
         0 (* Success status *)

     

       171
       171
       -
       ]}

     

       172
       172
       -
       

     

       173
       173
       -
       {2 Server Setup}

     

       174
       174
       -
       {[

     

       175
       175
       -
       let () = 

     

       176
       176
       -
         Eio_main.run @@ fun env ->

     

       177
       177
       -
         Eio.Switch.run @@ fun sw ->

     

       178
       178
       -
         Fastcgi.Request.serve ~sw ~backlog:128 ~port:9000 my_handler

     

       179
       179
       -
       ]}

     

       180
       180
       -
       *)

     

       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

Compare changes