Rework code to compile on latest rust nightly.

Author: s2172861

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 
 name = "fcgi"
-version = "0.0.2"
+version = "0.1.0"
 authors = ["Daniel Kaes <[email protected]>"]
 
 description = "Rust bindings for fast-cgi"
@@ -22,3 +22,5 @@ name = "echo"
 path = "examples/echo.rs"
 doc = false
 
+[dependencies]
+libc = "*"

examples/echo.rs

@@ -1,10 +1,9 @@
-
 extern crate fcgi;
 extern crate libc;
 
 use fcgi::{Request, DefaultRequest};
 use std::sync::{Arc, Mutex};
-use std::thread::Thread;
+use std::thread;
 
 static NTASKS: i32 = 8;
 
@@ -20,20 +19,22 @@ fn handle_request(accept_lock: Arc<Mutex<i32>> ) {
         let received = request.readall();
         request.write("Content-type: text/plain\r\n");
         request.write("\r\n");
-        request.write(received.as_slice());
+        request.write(received.as_ref());
         request.flush(fcgi::StreamType::OutStream);
         request.finish();
     }
 }
 
 fn main() {
+	
     fcgi::initialize_fcgi();
 
     let accept_lock = Arc::new(Mutex::new(0));
 
-    for _ in range(0, NTASKS) {
+    for _ in 0..NTASKS {
         let child_accept_lock = accept_lock.clone();
-        let _ = Thread::scoped(move || handle_request(child_accept_lock));
+        let t = thread::spawn(move || handle_request(child_accept_lock));
+        t.join().unwrap();
     }
 }
 

src/lib.rs

@@ -1,6 +1,7 @@
 
 #![crate_name = "fcgi"]
 #![crate_type = "lib"]
+#![feature(cstr_memory,cstr_to_str)] 
 
 //! This package provides a Rust binding to the C/C++ [fast-cgi library][]
 //!
@@ -43,11 +44,10 @@
 //! ```
 
 extern crate libc;
-use std::default::Default;
+use std::default::Default; 
 use std::ffi;
-use std::str;
-
-
+use std::ffi::{CString};
+use std::os::unix::io::{RawFd};
 pub mod capi;
 
 /// Initialize the FCGX library. Returns true upon success.
@@ -65,14 +65,17 @@ pub fn is_cgi() -> bool {
     }
 }
 
-#[deriving(Copy)]
+#[derive(Clone,Copy)]
 pub enum StreamType { OutStream, InStream, ErrStream }
 
 /// Methods for working with an FCGI request object. A default implementation is provided within this package.
 pub trait Request {
 
     /// Creates a new already initialized instance of an FCGI request.
-    fn new() -> Option<Self>;
+    fn new() -> Option<Self> where Self: Sized;
+    
+    /// Creates a new already initialized instance of an FCGI request.
+    fn new_with_fd(fd: RawFd) -> Option<Self> where Self: Sized;
 
     /// Accept a new request (multi-thread safe).  Be sure to call initialize_fcgi() first.
     fn accept(&mut self) -> bool;
@@ -121,6 +124,17 @@ impl Request for DefaultRequest {
             }
         }
     }
+    
+    fn new_with_fd(fd: RawFd) -> Option<DefaultRequest> {
+        let mut request: capi::FCGX_Request = Default::default();
+        unsafe {
+            if capi::FCGX_InitRequest(&mut request, fd, 0) == 0 {
+                return Some(DefaultRequest {raw_request: request });
+            } else {
+                return None;
+            }
+        }
+    }
 
     fn accept(&mut self) -> bool {
         unsafe {
@@ -135,27 +149,28 @@ impl Request for DefaultRequest {
     }
 
     fn get_param(&self, name: &str) -> Option<String> {
-        let cstr = ffi::CString::from_slice(name.as_bytes());
+    	let cstr = CString::new(name).unwrap();
         unsafe {
             let param = capi::FCGX_GetParam(cstr.as_ptr(), self.raw_request.envp);
             if param.is_null() {
                 return None;
             }
-            let resultStr = str::from_c_str(param);
-            return Some(String::from_str(resultStr));
+            let result_cstr = ffi::CString::from_ptr(param);
+            let result_str = result_cstr.to_str().unwrap();
+            return Some(String::from(result_str));
         }
     }
 
     fn write(&mut self, msg: &str) -> i32 {
-        let cstr = ffi::CString::from_slice(msg.as_bytes());
+        let cstr = ffi::CString::new(msg).unwrap();
         unsafe {
             return capi::FCGX_PutS(cstr.as_ptr(), self.raw_request.out_stream);
         }
     }
 
     fn error(&mut self, msg: &str) -> i32 {
-        let cstr = ffi::CString::from_slice(msg.as_bytes());
-        unsafe {
+        let cstr = ffi::CString::new(msg.as_bytes()).unwrap();
+        unsafe { 
             return capi::FCGX_PutS(cstr.as_ptr(), self.raw_request.err_stream);
         }
     }
@@ -167,22 +182,23 @@ impl Request for DefaultRequest {
             let pdst = buffer.as_mut_ptr();
             let byte_count = capi::FCGX_GetStr(pdst, n, self.raw_request.in_stream);
             buffer.set_len(byte_count as usize);
-            let resultStr = str::from_c_str(pdst);
-            return (String::from_str(resultStr), byte_count);
+            let result_cstr = ffi::CString::from_ptr(pdst);
+            let result_str = result_cstr.to_str().unwrap();
+            return (String::from(result_str), byte_count);
         }
     }
 
     fn readall(&mut self) -> String {
         let (mut msg, mut n) = self.read(512);
         while n == 512 {
             let (new_msg, new_n) = self.read(512);
-            msg = msg + new_msg.as_slice();
+            msg = msg + new_msg.as_ref();
             n = new_n;
         }
         return msg;
     }
 
-    fn flush(&mut self, stream_type: StreamType) {
+    fn flush(&mut self, stream_type: StreamType) { 
         let stream = match stream_type {
             StreamType::OutStream => self.raw_request.out_stream,
             StreamType::InStream  => self.raw_request.in_stream,