commit bd437dc577ebac8dc5cc0177c1d331ae06ae2b6e · anil.recoil.org/ocaml-fastcgi

+1 -1

bin/fcgi_server.ml

···

       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

     

       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;

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

+102

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

     

       94
       94
       +
         in

     

       95
       95
       +
         loop ()

     

       96
       96
       +
       

     

       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"

+64 -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
       +
       (** 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
       59
       +
       (** [handle_connection ~sw flow handler] handles complete FastCGI connection.

     

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

     

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

+47 -130

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

     
···

       273
       272
        
         

     

       274
       273
        
         List.rev !records

     

       275
       274
        
       

     

       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

     

       282
       282
       -
       

     

       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

     

       275
       275
       +
       let write_stream_records buf_write request_id record_type content =

     

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

     

       277
       277
       +
         let len = String.length content in

     

       278
       278
       +
         

     

       279
       279
       +
         let rec chunk_string pos =

     

       280
       280
       +
           if pos >= len then

     

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

     

       282
       282
       +
           else

     

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

     

       286
       286
       +
             Fastcgi_record.write buf_write record;

     

       287
       287
       +
             chunk_string (pos + chunk_len)

     

       292
       288
        
         in

     

       293
       289
        
         

     

       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

     

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

     

       294
       294
       +
         Fastcgi_record.write buf_write terminator

     

       299
       295
        
       

     

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

     

       296
       296
       +
       let write_stdout_records buf_write request_id content =

     

       297
       297
       +
         write_stream_records buf_write request_id Stdout content

     

       298
       298
       +
       

     

       299
       299
       +
       let write_stderr_records buf_write request_id content =

     

       300
       300
       +
         write_stream_records buf_write request_id Stderr content

     

       301
       301
       +
       

     

       302
       302
       +
       let write_end_request buf_write request_id app_status protocol_status =

     

       301
       303
        
         let content = 

     

       302
       304
        
           let buf = Bytes.create 8 in

     

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

     
···

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

     

       308
       310
        
           Bytes.to_string buf

     

       309
       311
        
         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 ()

     

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

     

       313
       313
       +
         Fastcgi_record.write buf_write record

     

       393
       314
        
       

     

       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"

+21 -104

lib/fastcgi_request.mli

···

       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

     

       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

     

       77
       74
        
       

     

       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

     

       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

     

       80
       78
        
       

     

       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

     

       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

     

       83
       81
        
       

     

       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

     

       120
       120
       -
       

     

       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
       82
        
       

     

       130
       83
        
       (** {1 Utilities} *)

     

       131
       84
        
       

     
···

       141
       94
        
         record_type:Fastcgi_record.record -> 

     

       142
       95
        
         string -> Fastcgi_record.t list

     

       143
       96
        
       

     

       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
       97
        
       

     

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