text stringlengths 12 786k |
|---|
type addr_info = { ai_family : socket_domain ; ai_socktype : socket_type ; ai_protocol : int ; ai_addr : sockaddr ; ai_canonname : string } |
type getaddrinfo_option = AI_FAMILY of socket_domain | AI_SOCKTYPE of socket_type | AI_PROTOCOL of int | AI_NUMERICHOST | AI_CANONNAME | AI_PASSIVE : string -> string -> getaddrinfo_option list -> addr_info list = " unix_getaddrinfo " |
let getaddrinfo_emulation node service opts = let opt_socktype = ref None and opt_protocol = ref 0 and opt_passive = ref false in List . iter ( function AI_SOCKTYPE s -> opt_socktype := Some s | AI_PROTOCOL p -> opt_protocol := p | AI_PASSIVE -> opt_passive := true | _ -> ( ) ) opts ; let ge... |
let getaddrinfo node service opts = try List . rev ( getaddrinfo_system node service opts ) with Invalid_argument _ -> getaddrinfo_emulation node service opts |
type name_info = { ni_hostname : string ; ni_service : string } |
type getnameinfo_option = NI_NOFQDN | NI_NUMERICHOST | NI_NAMEREQD | NI_NUMERICSERV | NI_DGRAM : sockaddr -> getnameinfo_option list -> name_info = " unix_getnameinfo " |
let getnameinfo_emulation addr opts = match addr with | ADDR_UNIX f -> { ni_hostname = " " ; ni_service = f } | ADDR_INET ( a , p ) -> let hostname = try if List . mem NI_NUMERICHOST opts then raise Not_found ; ( gethostbyaddr a ) . h_name with Not_found -> if List . mem NI_NAMEREQD... |
let getnameinfo addr opts = try getnameinfo_system addr opts with Invalid_argument _ -> getnameinfo_emulation addr opts file_descr -> file_descr -> file_descr -> int = " win_create_process " " win_create_process_native " |
let make_cmdline args = let maybe_quote f = if String . contains f ' ' || String . contains f ' " ' \ || String . contains f ' \ t ' || f = " " then Filename . quote f else f in String . concat " " ( List . map maybe_quote ( Array . to_list args ) ) |
let make_process_env env = Array . iter ( fun s -> if String . contains s ' \ 000 ' then raise ( Unix_error ( EINVAL , " " , s ) ) ) env ; String . concat " \ 000 " ( Array . to_list env ) ^ " \ 000 " |
let create_process prog args fd1 fd2 fd3 = win_create_process prog ( make_cmdline args ) None fd1 fd2 fd3 |
let create_process_env prog args env fd1 fd2 fd3 = win_create_process prog ( make_cmdline args ) ( Some ( make_process_env env ) ) fd1 fd2 fd3 |
type popen_process = Process of in_channel * out_channel | Process_in of in_channel | Process_out of out_channel | Process_full of in_channel * out_channel * in_channel |
let popen_processes = ( Hashtbl . create 7 : ( popen_process , int ) Hashtbl . t ) |
let open_proc prog cmdline optenv proc input output error = let pid = win_create_process prog cmdline optenv input output error in Hashtbl . add popen_processes proc pid |
let open_process_cmdline_in prog cmdline = let ( in_read , in_write ) = pipe ~ cloexec : true ( ) in let inchan = in_channel_of_descr in_read in begin try open_proc prog cmdline None ( Process_in inchan ) stdin in_write stderr with e -> close_in inchan ; close in_write ; raise e end ; close in... |
let open_process_cmdline_out prog cmdline = let ( out_read , out_write ) = pipe ~ cloexec : true ( ) in let outchan = out_channel_of_descr out_write in begin try open_proc prog cmdline None ( Process_out outchan ) out_read stdout stderr with e -> close_out outchan ; close out_read ; raise e end ... |
let open_process_cmdline prog cmdline = let ( in_read , in_write ) = pipe ~ cloexec : true ( ) in let ( out_read , out_write ) = try pipe ~ cloexec : true ( ) with e -> close in_read ; close in_write ; raise e in let inchan = in_channel_of_descr in_read in let outchan = out_channel_of_... |
let open_process_cmdline_full prog cmdline env = let ( in_read , in_write ) = pipe ~ cloexec : true ( ) in let ( out_read , out_write ) = try pipe ~ cloexec : true ( ) with e -> close in_read ; close in_write ; raise e in let ( err_read , err_write ) = try pipe ~ cloexec : true ... |
let open_process_args_in prog args = open_process_cmdline_in prog ( make_cmdline args ) |
let open_process_args_out prog args = open_process_cmdline_out prog ( make_cmdline args ) |
let open_process_args prog args = open_process_cmdline prog ( make_cmdline args ) |
let open_process_args_full prog args = open_process_cmdline_full prog ( make_cmdline args ) |
let open_process_shell fn cmd = let shell = try Sys . getenv " COMSPEC " with Not_found -> raise ( Unix_error ( ENOEXEC , " open_process_shell " , cmd ) ) in fn shell ( shell ^ " / c " ^ cmd ) |
let open_process_in cmd = open_process_shell open_process_cmdline_in cmd |
let open_process_out cmd = open_process_shell open_process_cmdline_out cmd |
let open_process cmd = open_process_shell open_process_cmdline cmd |
let open_process_full cmd = open_process_shell open_process_cmdline_full cmd |
let find_proc_id fun_name proc = try Hashtbl . find popen_processes proc with Not_found -> raise ( Unix_error ( EBADF , fun_name , " " ) ) |
let remove_proc_id proc = Hashtbl . remove popen_processes proc |
let process_in_pid inchan = find_proc_id " process_in_pid " ( Process_in inchan ) |
let process_out_pid outchan = find_proc_id " process_out_pid " ( Process_out outchan ) |
let process_pid ( inchan , outchan ) = find_proc_id " process_pid " ( Process ( inchan , outchan ) ) |
let process_full_pid ( inchan , outchan , errchan ) = find_proc_id " process_full_pid " ( Process_full ( inchan , outchan , errchan ) ) |
let close_process_in inchan = let proc = Process_in inchan in let pid = find_proc_id " close_process_in " proc in remove_proc_id proc ; close_in inchan ; snd ( waitpid [ ] pid ) |
let close_process_out outchan = let proc = Process_out outchan in let pid = find_proc_id " close_process_out " proc in remove_proc_id proc ; close_out outchan ; snd ( waitpid [ ] pid ) |
let close_process ( inchan , outchan ) = let proc = Process ( inchan , outchan ) in let pid = find_proc_id " close_process " proc in remove_proc_id proc ; close_in inchan ; close_out outchan ; snd ( waitpid [ ] pid ) |
let close_process_full ( inchan , outchan , errchan ) = let proc = Process_full ( inchan , outchan , errchan ) in let pid = find_proc_id " close_process_full " proc in remove_proc_id proc ; close_in inchan ; close_out outchan ; close_in errchan ; snd ( waitpid [ ] pid ) file_descr... |
let open_connection sockaddr = let sock = socket ~ cloexec : true ( domain_of_sockaddr sockaddr ) SOCK_STREAM 0 in try connect sock sockaddr ; ( in_channel_of_descr sock , out_channel_of_descr sock ) with exn -> close sock ; raise exn |
let shutdown_connection inchan = shutdown ( descr_of_in_channel inchan ) SHUTDOWN_SEND |
let establish_server _server_fun _sockaddr = invalid_arg " Unix . establish_server not implemented " |
type terminal_io = { mutable c_ignbrk : bool ; mutable c_brkint : bool ; mutable c_ignpar : bool ; mutable c_parmrk : bool ; mutable c_inpck : bool ; mutable c_istrip : bool ; mutable c_inlcr : bool ; mutable c_igncr : bool ; mutable c_icrnl : bool ; mutable c_ixon : bool ; mutable c_ix... |
type setattr_when = TCSANOW | TCSADRAIN | TCSAFLUSH |
let tcgetattr _fd = invalid_arg " Unix . tcgetattr not implemented " |
let tcsetattr _fd _wh = invalid_arg " Unix . tcsetattr not implemented " |
let tcsendbreak _fd _n = invalid_arg " Unix . tcsendbreak not implemented " |
let tcdrain _fd = invalid_arg " Unix . tcdrain not implemented " |
type flush_queue = TCIFLUSH | TCOFLUSH | TCIOFLUSH |
let tcflush _fd _q = invalid_arg " Unix . tcflush not implemented " |
type flow_action = TCOOFF | TCOON | TCIOFF | TCION |
let tcflow _fd _fl = invalid_arg " Unix . tcflow not implemented " |
let setsid ( ) = invalid_arg " Unix . setsid not implemented " |
let unlink_safe file = try Unix . unlink file with _ -> ( ) |
let mkdir_safe dir perm = try Unix . mkdir dir perm with Unix . Unix_error ( Unix . EEXIST , _ , _ ) -> ( ) |
let mkdir_rec dir perm = let rec p_mkdir dir = let p_name = Filename . dirname dir in if p_name <> " " / && p_name <> " . " then p_mkdir p_name ; mkdir_safe dir perm in p_mkdir dir |
let pidfile_write filename = let fd = Unix . openfile filename [ Unix . O_WRONLY ; Unix . O_CREAT ; Unix . O_TRUNC ; ] 0o640 in finally ( fun ( ) -> let pid = Unix . getpid ( ) in let buf = string_of_int pid ^ " \ n " in let len = String . length buf in if Unix . write fd ... |
let pidfile_read filename = let fd = Unix . openfile filename [ Unix . O_RDONLY ] 0o640 in finally ( fun ( ) -> try let buf = Bytes . create 80 in let rd = Unix . read fd buf 0 ( Bytes . length buf ) in if rd = 0 then failwith " pidfile_read failed " ; Scanf . sscanf ( Bytes ... |
let with_file file mode perms f = let fd = Unix . openfile file mode perms in Xapi_stdext_pervasives . Pervasiveext . finally ( fun ( ) -> f fd ) ( fun ( ) -> Unix . close fd ) |
let daemonize ( ) = match Unix . fork ( ) with | 0 -> if Unix . setsid ( ) == - 1 then failwith " Unix . setsid failed " ; begin match Unix . fork ( ) with | 0 -> with_file " / dev / null " [ Unix . O_WRONLY ] 0 ( fun nullfd -> Unix . close Unix . stdin ; Un... |
let lines_fold f start input = let accumulator = ref start in let running = ref true in while ! running do let line = try Some ( input_line input ) with End_of_file -> None in match line with | Some line -> begin try accumulator := ( f ! accumulator line ) with Break -> running := false end | None ... |
let lines_iter f = lines_fold ( fun ( ) line -> ignore ( f line ) ) ( ) |
let with_input_channel file f = let input = open_in file in finally ( fun ( ) -> f input ) ( fun ( ) -> close_in input ) |
let file_lines_fold f start file_path = with_input_channel file_path ( lines_fold f start ) |
let read_lines ( ~ path : string ) : string list = List . rev ( file_lines_fold ( fun acc line -> line :: acc ) [ ] path ) |
let file_lines_iter f = file_lines_fold ( fun ( ) line -> ignore ( f line ) ) ( ) |
let fd_blocks_fold block_size f start fd = let block = Bytes . create block_size in let rec fold acc = let n = Unix . read fd block 0 block_size in let b = if n = block_size then block else Bytes . sub block 0 n in if n = 0 then acc else fold ( f acc b ) in fold start |
let with_directory dir f = let dh = Unix . opendir dir in Xapi_stdext_pervasives . Pervasiveext . finally ( fun ( ) -> f dh ) ( fun ( ) -> Unix . closedir dh ) |
let buffer_of_fd fd = fd_blocks_fold 1024 ( fun b s -> Buffer . add_bytes b s ; b ) ( Buffer . create 1024 ) fd |
let string_of_fd fd = Buffer . contents ( buffer_of_fd fd ) |
let buffer_of_file file_path = with_file file_path [ Unix . O_RDONLY ] 0 buffer_of_fd |
let string_of_file file_path = Buffer . contents ( buffer_of_file file_path ) |
let atomic_write_to_file fname perms f = let dir_path = Filename . dirname fname in let tmp_path , tmp_chan = Filename . open_temp_file ~ temp_dir : dir_path " " " . tmp " in let tmp_fd = Unix . descr_of_out_channel tmp_chan in let write_tmp_file ( ) = let result = f tmp_fd in Unix . fch... |
let write_bytes_to_file fname b = atomic_write_to_file fname 0o644 ( fun fd -> let len = Bytes . length b in let written = Unix . write fd b 0 len in if written <> len then ( failwith " Short write occured " ) ) ! |
let write_string_to_file fname s = write_bytes_to_file fname ( Bytes . unsafe_of_string s ) |
let execv_get_output cmd args = let ( pipe_exit , pipe_entrance ) = Unix . pipe ( ) in let r = try Unix . set_close_on_exec pipe_exit ; true with _ -> false in match Unix . fork ( ) with | 0 -> Unix . dup2 pipe_entrance Unix . stdout ; Unix . close pipe_entrance ; if not r then U... |
let copy_file_internal ? limit reader writer = let buffer = Bytes . make 65536 ' \ 000 ' in let buffer_len = Int64 . of_int ( Bytes . length buffer ) in let finished = ref false in let total_bytes = ref 0L in let limit = ref limit in while not ( ! finished ) do let requested = min ( Opt... |
let copy_file ? limit ifd ofd = copy_file_internal ? limit ( Unix . read ifd ) ( Unix . write ofd ) |
let file_exists file_path = try Unix . access file_path [ Unix . F_OK ] ; true with _ -> false |
let touch_file file_path = let fd = Unix . openfile file_path [ Unix . O_WRONLY ; Unix . O_CREAT ; Unix . O_NOCTTY ; Unix . O_NONBLOCK ] 0o666 in Unix . close fd ; Unix . utimes file_path 0 . 0 0 . 0 |
let is_empty_file file_path = try let stats = Unix . stat file_path in stats . Unix . st_size = 0 with Unix . Unix_error ( Unix . ENOENT , _ , _ ) -> false |
let delete_empty_file file_path = if is_empty_file file_path then ( Sys . remove file_path ; true ) else ( false ) |
let open_connection_fd host port = let open Unix in let addrinfo = getaddrinfo host ( string_of_int port ) [ AI_SOCKTYPE SOCK_STREAM ] in match addrinfo with | [ ] -> failwith ( Printf . sprintf " Couldn ' t resolve hostname : % s " host ) | ai :: _ -> let s = socket ai . ai_family ... |
let open_connection_unix_fd filename = let s = Unix . socket Unix . PF_UNIX Unix . SOCK_STREAM 0 in try let addr = Unix . ADDR_UNIX ( filename ) in Unix . connect s addr ; s with e -> Backtrace . is_important e ; Unix . close s ; raise e |
module CBuf = struct type t = { mutable buffer : bytes ; mutable len : int ; mutable start : int ; mutable r_closed : bool ; mutable w_closed : bool ; } let empty length = { buffer = Bytes . create length ; len = 0 ; start = 0 ; r_closed = false ; w_closed = false ; } let dr... |
let kill_and_wait ( ? signal = Sys . sigterm ) ( ? timeout = 10 . ) pid = let proc_entry_exists pid = try Unix . access ( Printf . sprintf " / proc /% d " pid ) [ Unix . F_OK ] ; true with _ -> false in if pid > 0 && proc_entry_exists pid then ( let loop_time_waiting = 0... |
let string_of_signal x = let table = [ Sys . sigabrt , " SIGABRT " ; Sys . sigalrm , " SIGALRM " ; Sys . sigfpe , " SIGFPE " ; Sys . sighup , " SIGHUP " ; Sys . sigill , " SIGILL " ; Sys . sigint , " SIGINT " ; Sys . sigkill , " SIGKILL " ; Sys .... |
let proxy ( a : Unix . file_descr ) ( b : Unix . file_descr ) = let size = 64 * 1024 in let a ' = CBuf . empty size and b ' = CBuf . empty size in Unix . set_nonblock a ; Unix . set_nonblock b ; try while true do let r = ( if CBuf . should_read a ' then [ a ] else [ ] ... |
let rec really_read fd string off n = if n = 0 then ( ) else let m = Unix . read fd string off n in if m = 0 then raise End_of_file ; really_read fd string ( off + m ) ( n - m ) |
let really_read_string fd length = let buf = Bytes . make length ' \ 000 ' in really_read fd buf 0 length ; Bytes . unsafe_to_string buf |
let try_read_string ? limit fd = let buf = Buffer . create 0 in let chunk = match limit with None -> 4096 | Some x -> x in let cache = Bytes . make chunk ' \ 000 ' in let finished = ref false in while not ! finished do let to_read = match limit with | Some x -> min ( x - ( Buffer . lengt... |
let rec restart_on_EINTR f x = try f x with Unix . Unix_error ( Unix . EINTR , _ , _ ) -> restart_on_EINTR f x let n = restart_on_EINTR ( Unix . single_write_substring fd buffer offset ) len in if n < len then really_write fd buffer ( offset + n ) ( len - n ) ; ; |
let really_write_string fd string = really_write fd string 0 ( String . length string ) |
let time_limited_write_internal ( write : Unix . file_descr -> ' a -> int -> int -> int ) filedesc length data target_response_time = let total_bytes_to_write = length in let bytes_written = ref 0 in let now = ref ( Unix . gettimeofday ( ) ) in while ! bytes_written < total_bytes_to_write ... |
let time_limited_write filedesc length data target_response_time = time_limited_write_internal Unix . write filedesc length data target_response_time |
let time_limited_write_substring filedesc length data target_response_time = time_limited_write_internal Unix . write_substring filedesc length data target_response_time |
let time_limited_read filedesc length target_response_time = let total_bytes_to_read = length in let bytes_read = ref 0 in let buf = Bytes . make total_bytes_to_read ' \ 000 ' in let now = ref ( Unix . gettimeofday ( ) ) in while ! bytes_read < total_bytes_to_read && ! now < target_response... |
let read_data_in_chunks_internal ( sub : bytes -> int -> int -> ' a ) ( f : ' a -> int -> unit ) ( ? block_size = 1024 ) ( ? max_bytes = - 1 ) from_fd = let buf = Bytes . make block_size ' \ 000 ' in let rec do_read acc = let remaining_bytes = max_bytes - acc in if remaini... |
let read_data_in_string_chunks ( f : string -> int -> unit ) ( ? block_size = 1024 ) ( ? max_bytes = - 1 ) from_fd = read_data_in_chunks_internal Bytes . sub_string f ~ block_size ~ max_bytes from_fd |
let read_data_in_chunks ( f : bytes -> int -> unit ) ( ? block_size = 1024 ) ( ? max_bytes = - 1 ) from_fd = read_data_in_chunks_internal Bytes . sub f ~ block_size ~ max_bytes from_fd |
let spawnvp ( ? pid_callback ( = fun _ -> ( ) ) ) cmd args = match Unix . fork ( ) with | 0 -> Unix . execvp cmd args | pid -> begin try pid_callback pid with _ -> ( ) end ; snd ( Unix . waitpid [ ] pid ) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.