This is a continuation from gdb part1 post -
http://naveendavisv.blogspot.com/2020/02/gdb-tips-part1.html
- Debug an executable:
gdb executable
- Attach a process to gdb:
gdb -p procID
- Debug with a core file:
gdb -c core executable
- Execute given GDB commands upon start:
gdb -ex "commands" executable
- Start gdb and pass arguments:
gdb --args executable argument1 argument2
Dangling Pointers in C
If you try to free a pointer and then try to access it, the C compiler won’t complains it. But you will be come to know that bug in the run time.
1 #include<stdio.h>
2 #include<stdlib.h>
3
4 int main(){
5
6 int* ptr = (int*) malloc(2*sizeof(int));
7
8 *ptr= 10;
9 ptr++;
10 *ptr = 20;
11
12 free(ptr);
13
14 printf("pointer values are %d",*ptr);
15
16 }
This is the runtime error: I know that you hate runt ime errors . But that is what happens when we try to access pointers that are already freed. We won’t any clue until we encounter this error in C.
======= Backtrace: =========
/lib/x86_64-linux-gnu/libc.so.6(+0x777e5)[0x7f97ccd4e7e5]
/lib/x86_64-linux-gnu/libc.so.6(+0x8037a)[0x7f97ccd5737a]
/lib/x86_64-linux-gnu/libc.so.6(cfree+0x4c)[0x7f97ccd5b53c]
./a.out[0x4005f1]
/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xf0)[0x7f97cccf7830]
./a.out[0x4004e9]
======= Memory map: ========
00400000-00401000 r-xp 00000000 08:06 6554103 /home/naveen/rustprojects/mar2020/C_Rust_$omp/a.out
00600000-00601000 r--p 00000000 08:06 6554103 /home/naveen/rustprojects/mar2020/C_Rust_$omp/a.out
00601000-00602000 rw-p 00001000 08:06 6554103 /home/naveen/rustprojects/mar2020/C_Rust_$omp/a.out
020fa000-0211b000 rw-p 00000000 00:00 0 [heap]
7f97c8000000-7f97c8021000 rw-p 00000000 00:00 0
But Rust save us here.
Rust:
1 fn main() {
2
3 let a = vec!(10,11,14); // vector 'a' is initialized.
4 let p = &a ; // reference to the value in 'a'.
5
6 drop(a); //free the memory allocated for 'a'
7
8 //we can try to access values in 'a' through reference 'p'
9 println!(" values in a = {:?}",*p);
10 }
The famous error comes in compile time itself
Rust complains “borrow later used here” means we dropped the value and but still trying to access it.
borrow means: when we create a reference to the value, we are just borrowing the value.In this case the ownership of the value still remains with ‘a’.
So when we dropped the value ‘a’. The borrowed reference is also become invalid and we can’t use it later point in the program.
error[E0505]: cannot move out of `a` because it is borrowed
--> src/main.rs:9:10
|
7 | let p = &a ; // reference to the value in 'a'.
| -- borrow of `a` occurs here
8 |
9 | drop(a); //free the memory allocated for 'a'
| ^ move out of `a` occurs here
...
12 | println!(" values in a = {:?}",*p);
| -- borrow later used here
error: aborting due to previous error
For more information about this error, try `rustc --explain E0505`.
error: could not compile `dangling`.
To learn more, run the command again with --verbose.
This is one of the well known problem in C programming language - Array Overflow.
C compiler really won’t care the boundary of arrays , you can even point to the value beyond array length using a pointer as if you are traversing through it.
C Program
1
2 int main(){
3
4 int a[3] = {1,2,3 };
5 char c = 'a';
6 char d = 'b';
//pointer to the array,
//usually array itself is a pointer
// to the first address of the array
7 printf("array = %d " , *a );
8 printf("array = %d " , *(a+1) );
9 printf("array = %d " , *(a+2) );
10
11
12 //memory overflow , we are trying to access beyond array's length
13 //but compiling is not complaining
14
15 printf("array = %d " , *(a+3) );
16 printf("array = %d " , a[5] );
17
18 }
Output is
array = 1 array = 2 array = 3 array = 0 array = 32764
We will see how Rust program restricts this vulnerability .
Rust Program
trying to create pointer and dereferencing it below, but compiler catches it
1
2 fn main() {
3
4 let a = [1,2,4];
5
6 let p = &a;
7
8 println!("array ={:?}",*p+1);
9
10 }
error is
--> src/main.rs:8:31
|
8 | println!("array ={:?}",*(p+1));
| -^- {integer}
| |
| &[{integer}; 3]
if you try to access it through index, as a[3] , below is the error
error: this operation will panic at runtime
--> src/main.rs:8:26
|
8 | println!("array = {}",a[3]);
| ^^^^ index out of bounds: the len is 3 but the index is 3
|
= note: `#[deny(unconditional_panic)]` on by default
Looks at the below program, how crazy the ‘main’ function snatches the password from the function ‘assign’. We only return the pointer to the ‘user’, but ‘main’ gets ‘password’ from it.
It took some trials for me to find number nine(9) as the offset (byte) ( difference between the “user” and " password" address ) .
C code
l 1
2 #include<stdlib.h>
3
4 char* assign(){
5
6 char password = 'a'; //password stored here
7 char b[3] = "ab";
8
9 int* username = &b;
10
11 return username;
12 }
13
14
15
16 int main(){
17
18 char* user = NULL;
19
20 user = assign();
21 // you can just do some address offseting with "-" or "+" to get the "password" field
22 printf("%c\n",*(user - 9));
23
24 }
Output is ‘a’ which is the password here.
a
Rust code:
In rust it is very difficult or not even possible ( I don’t know a method) without unsafe code to offset the address and get another variables or string slices(literals).
Interestingly “password” and “username” variables are referring to the program memory itself ( not stack or heap ) as &str ( string slice) hard coding in program binary.
We can try with "unsafe " code to do some manipulation on the username address to snatch the “password”.
But if you are making sure that no ‘unsafe’ code in your program , you can avoid this scenario in rust or you will catch those scenario on compile time itself ( that is AWESOME! )
2 fn assign() -> &'static str{
3
4 let password = "q";
5 let username = "asdasd";
6
7 let q = username;
8
9
10 println!("pointer = {:p}, {:p}",password,q);
11
12 q
13
14 }
15
16
17 fn main() {
18
19 let p:&str = assign();
20
21 let ptr: *const u8 = p.as_ptr();
22
/// you really need to write unsafe code and
/// do some trick to get offset address of the
/// "password" here. The + , - operators won't work with address in rust.
23 unsafe {
24 println!("Hello, world! : {}",*ptr.sub(1) as char);
25 }
26
27 }
Output is
pointer = 0x5638e3aa3d70, 0x5638e3aa3d71
Hello, world! : q
fn foo(x:i32,mult:P) -> i32where P: Fn(i32) -> boolfoo(220,mult1); which is a valid call because the ‘‘mult1’’ function signature matches with generic type ///foo function definition - it has 2 parameter
/// an integer value and a passed function
///return type of the function is integer
fn foo(x:i32,mult:P) -> i32
/// passed function type
where P: Fn(i32) -> bool {
///calling the passed function and getting the return value
let y = mult(x);
///some calculation around based on the value 'y'
if y {
x
}else{
x - 1
}
}
///the signature of this function matches with foo's passed function signature 'P'
fn mult1(x:i32) -> bool {
x> 32
}
///the signature of this function not matches with foo's passed function signature 'P'
///as it return integer
fn mult2(x:i32) -> i32{
x
}
fn main() {
///call to foo with passed function 'mult1'
let q = foo(220,mult1);
println!("Hello, world! = {}",q);
}
foo(220,mult2);error[E0271]: type mismatch resolving ` i32 {mult2} as std::ops::FnOnce<(i32,)>>::Output == bool`
--> src/main.rs:30:13
|
2 | fn foo(x:i32,mult:P) -> i32
| ---
3 |
4 | where P: Fn(i32) -> bool {
| ---- required by this bound in `foo`
...
30 | let q = foo(220,mult2);
| ^^^ expected `bool`, found `i32`
error: aborting due to previous error
For more information about this error, try `rustc --explain E0271`.
error: could not compile `funexp1`.
To learn more, run the command again with --verbose.
where P: Fn(i32) -> bool {
| ---- required by this bound in `foo`
One of the main strength of Rust programming language is that it can easily inter-operate with other programming languages.
But as we know Rust is very very strongly typed language. When you are planning Rust to use some of the C libraries , the C type representation attributes help us .
There are some difference in the type representation for C type corresponding rust type.
We can go-ahead and check what is the size of the below struct
https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=7392513792a8d390ce4756a6a8a0ed15
use std::mem;
#[repr(C)]
struct FieldStruct {
first: u8,
second: u16,
third: u8
}
// The size of the first field is 1, so add 1 to the size. Size is 1.
// The alignment of the second field is 2, so add 1 to the size for padding. Size is 2.
// The size of the second field is 2, so add 2 to the size. Size is 4.
// The alignment of the third field is 1, so add 0 to the size for padding. Size is 4.
// The size of the third field is 1, so add 1 to the size. Size is 5.
// Finally, the alignment of the struct is 2 (because the largest alignment amongst its
// fields is 2), so add 1 to the size for padding. Size is 6.
assert_eq!(6, mem::size_of::<FieldStruct>());
}
But if you remove #[repr( c )] , the struct size becomes 4.
#![allow(unused)]
fn main() {
use std::mem;
struct FieldStruct {
first: u8,
second: u16,
third: u8
}
assert_eq!(6, mem::size_of::<FieldStruct>());
}
I referred the blog for Sergey Potapov for the details.
In this below program, you would see the function print_hello_from_rust defined with extern keyword and [no_mangle] attribute.
[no_mangle] makes the compiler ignores the unknown symbols and it knows this function is going to get called from other languages.
extern keyword makes the function outside of the our library.
std::ffi::CStr. Representation of a borrowed C string. This type represents a borrowed reference to a nul-terminated array of bytes. It can be constructed safely from a &[ u8 ] slice, or unsafely from a raw *const c_char
In this example we are using *const c_char , but what is c_char ?!
c_char is coming from the standard library ‘os’ module and it is Equivalent to C’s char type.C’s char type is completely unlike Rust’s char type; while Rust’s type represents a unicode scalar value, C’s char type is just an ordinary integer. This type will always be either i8 or u8, as the type is defined as being one byte long
reference : c_char
then why *const in front of it ?
*const are called Raw pointers in Rust.Sometimes, when writing certain kinds of libraries, you’ll need to get around Rust’s safety guarantees for some reason. In this case, you can use raw pointers to implement your library, while exposing a safe interface for your users. Ref: Raw pointers
use std::ffi::{CString,CStr};
use std::os::raw::{c_char,c_int};
#[repr(C)]
pub struct Point{
x: c_int,
y: c_int,
}
impl Point {
fn new(x:c_int,y:c_int) -> Point{
// println!("Creating a Point with x = {},y = {}",x,y);
Point {x: x,y: y }
}
}
#[no_mangle]
pub extern fn create_point(x:c_int,y:c_int) -> *mut Point{
Box::into_raw(Box::new(Point::new(x,y)))
}
#[no_mangle]
pub extern fn print_hello_from_rust(data: *const c_char ){
unsafe{
let c_str = CStr::from_ptr(data);
println!("hello from rust {:?}",c_str.to_str().unwrap());
}
}
You can build the rust program with cargo
cargo new whatland -- lib
cd whatland
edit the lib.rs file with above code.
also make sure that your cargo file has
[lib]
name = "whatland"
crate-type = ["staticlib","cdylib"]
cdylib helps - A dynamic system library creation. This is used when compiling a dynamic library to be loaded from another language. This output type will create *.so files on Linux, *.dylib files on macOS, and *.dll files on Windows.
cargo build --release
I am not detailing the C program compilation, but it detailed in the blogpost: https://www.greyblake.com/blog/2017-08-10-exposing-rust-library-to-c/
You would need to use,
gcc -o ./examples/hello ./examples/hello.c -Isrc -L. -l:target/release/libwhatlang.so
We can use the trick of accepting the string as a Raw pointer using *const c_char
In order to print that bytes into a valid string slice in Rust, first we need to convert that to CStr - Representation of a borrowed C string.
then we can convert that to Str ( rust string slice) using c_str.to_str().unwrap()
I believe , Its always recommended to use #[repr©] when working with C structs, enums because it makes alignment https://doc.rust-lang.org/reference/type-layout.html#the-c-representation
#[repr(C)]
pub struct Point{
x: c_int,
y: c_int,
// x:u8, -- if you are using u8, compilier throws error,
// y:u8, stating "expected `u8`, found `i32'"
}
We implemented a method new in the rust program so that we can use in the Point struct instance creation.
impl Point {
fn new(x:c_int,y:c_int) -> Point{
Point {x: x,y: y }
}
}
Next in this example we have a export function which will be called from C program to creating Point Struct. For creating any object, we need to memory. In Rust we know that we can allocate heap memory through Box::new.
But we need to return a raw pointer to the C program, which can be done through Box::into_raw which Consumes the Box, returning a wrapped raw pointer.
23 #[no_mangle]
24 pub extern fn create_point(x:c_int,y:c_int) -> *mut Point{
25
26 Box::into_raw(Box::new(Point::new(x,y)))
27 }
We need to have our C program included with struct and create function declaration.
header file whatland.h
1 void print_hello_from_rust();
2
3 typedef struct Point{
4 int x,y;
5 }Point;
6
7 Point* create_point(int x, int y);
Now we can just call it in our main function in C
11 Point* p1 = create_point(10,20);
12 printf("Point={%d},{%d}",p1 -> x,p1 -> y);
When I got this question first time, I don’t know where to start with this in Rust.
If this question was to write the same prgoram in C :
C is a school taught language and we know that C 's stdio has fopen, fclose ,fgets etc … because of that I wouldn’t have worried what/how fgets read or type conversion challenges are handled.
Here in Rust , I don’t which libraries/modules needs to imported
libraries are called crates in rust.
Some of the questions came to mind where
Looks like all these details are well documented in
std lib in rust
Finally I just started writing the program with whatever read method that I found somewhat relevant
1 use std::fs::File;
2
3 fn main() {
4
5 let f = File::open("a.txt");
6
7 match f.read() {
8 Ok(x) => { println!("file contents = {}",x) },
9 Err(e) => { println!("Error") },
10 }
11 }
Oops Error…
compiler complaints …
error[E0599]: no method named `read` found for enum `std::result::Result<std::fs::File, std::io::Error>` in the current scope
--> src/main.rs:7:13
|
7 | match f.read() {
| ^^^^ method not found in `std::result::Result<std::fs::File, std::io::Error>`
error: aborting due to previous error
For more information about this error, try `rustc --explain E0599`.
error: could not compile `std_learning1`.
Ok. read method is not there in fs inmodule.
We will goahead search where is the read in rust lang documentation.
I used std::fs::read , but if we read through the documentation carefully , we will understand that this is for small files and that can be parsed to a string format type like SocketAddr.
9 | match std::fs::read(f) {
| ^ the trait `std::convert::AsRef<std::path::Path>` is not implemented for `std::result::Result<std::fs::File, std::io::Error>
This error actually gives a clue that our “f” file object is “std::result::Result<std::fs::File, std::io::Error>”
I know that I can handles the error types with just adding “?” to file open.
But still we haven’t got which read method to use . Again going to back to documentation and search - I found a read that reasonable choice which is std::io:: Read::read
(Note:wrongly highlighted above)
just brought std::io::Read trait alone to the program for now.
as the function signature says -
fn read(&mut self, buf: &mut [u8]) -> Result<usize >
1 use std::fs::File;
2 use std::io::Read;
4
5 fn main() {
6
7 let mut f = File::open("a.txt")?;
8 let mut buf = [0;30];
9 let n = f.read(&mut buf[..]);
14
15 println!("{:?}",&buf[0..n]);
16
18 }
mainly two errors
| |
7 | | let mut f = File::open("a.txt")?;
| | ^^^^^^^^^^^^^^^^^^^^ cannot use the `?` operator in a function that returns `()`
8 | | let mut buf = [0;30];
error[E0308]: mismatched types
--> src/main.rs:15:29
|
15 | println!("{:?}",&buf[0..n]);
| ^ expected integer, found enum `std::result::Result`
|
= note: expected type `{integer}`
found enum `std::result::Result<usize, std::io::Error>`
error: aborting due to 2 previous errors
we need to give return type in the main() function as we used “?” in line 7 and also we need to return Ok(()) in the main
We need to add io::Result<()> as return type in the main function, so for that we would need to include std::io;
So code would looks something like below:
1 use std::fs::File;
2 use std::io::Read;
3
4 use std::io;
5 //use std::io::prelude::*;
6
7 fn main() -> io::Result<()> {
8
9 let mut f = File::open("a.txt")?;
10 let mut buf = [0;30];
11 let n = f.read(&mut buf[..])?;
17 println!("{:?}",&buf[0..n]);
18
19 Ok(())
20 }
But the output is still bytes.
Finished dev [unoptimized + debuginfo] target(s) in 0.01s
Running `/home/naveen/rustprojects/mar2020/std_learning1/target/debug/std_learning1`
[84, 104, 105, 115, 32, 105, 115, 32, 102, 105, 114, 115, 116, 32, 82, 117, 115, 116, 32, 115, 116, 100, 32, 108, 105, 98, 114, 97, 114, 121]
We can convert the bytes to string type using below statements.
println!("{:?}",String::from_utf8((&buf[0..n]).to_vec()).unwrap());
One you might have noticed is that we need to handle the buffer explicitly.
So let us look again for some other read method available.
The one I found interesting is BufRead Trait which is a type reader that handle internal buffer.
Let us search for what are all the methods implementing this.
But how it can be used or related to File struct.
We know that File implements Read trait.
BufReader implements Read
BufReader implements BufRead as well.
So we can go-ahead are use/create an instance of BufReader on a File object.
Once we convert File object to an instance of BufReader , we can use methods like
lines
read_lines
read_until
split
1 use std::fs::File;
2 //use std::io::Read;
3
4 use std::io::{self,BufReader};
5
6 //include io prelude which import all important structs and implementation
7 //in this case it import all supporting BufReader implementation ( eg : //BufRead) for File struct.
9
10
11 use std::io::prelude::*;
12
13 fn main() -> io::Result<()> {
14
15 let mut f = File::open("a.txt")?;
16 // let mut buf = [0;30];
17
18 let buf = BufReader::new(f);
19
20 // let n = f.read(&mut buf[..])?;
21
22 for line in buf.lines(){
23 println!("{:?}",line);
24 }
25
26
27 Ok(())
28 }
Diagram might be not fully correct. But I am trying to picturize the File read program modules and important internals.
Some notes in the above snippet:
include io::prelude which import all important structs and implementation. in this case it import all supporting BufReader implementation ( eg : BufRead) for File struct.
commented some of the lines(not deleted) which we used prior version of the program to understand the difference.
Output :
Ok("This is first Rust std library learning program.")
if we do an unwrap(), we will get the line string itself.
Conclusion:
Hope this helps you to understand how different traits are connected together at least for Rust File read program and which std modules needs to be imported for it. This same module/trait analysis required when you are working with external crates. It is important reading through the crate documentation and understand which traits are matching your requirement and which are needs to be imported and ready to use for their methods.