mem_rs/memory/read_write.rs
1// This file is part of the mem-rs distribution (https://github.com/FrankvdStam/mem-rs).
2// Copyright (c) 2022 Frank van der Stam.
3// https://github.com/FrankvdStam/mem-rs/blob/main/LICENSE
4//
5// This program is free software: you can redistribute it and/or modify
6// it under the terms of the GNU General Public License as published by
7// the Free Software Foundation, version 3.
8//
9// This program is distributed in the hope that it will be useful, but
10// WITHOUT ANY WARRANTY without even the implied warranty of
11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12// General Public License for more details.
13//
14// You should have received a copy of the GNU General Public License
15// along with this program. If not, see <http://www.gnu.org/licenses/>.
16
17use crate::memory::base_read_write::BaseReadWrite;
18
19pub trait ReadWrite: BaseReadWrite
20{
21 //==================================================================================================================================================================
22 //Reading
23
24 /// Relatively read an i8 from an optional offset
25 ///
26 /// # Example
27 ///
28 /// ```
29 /// use mem_rs::prelude::*;
30 ///
31 /// let mut process = Process::new("name_of_process.exe");
32 /// process.refresh()?;
33 /// let pointer = process.create_pointer(0x1234, vec![0]);
34 ///
35 /// let data = pointer.read_i8_rel(Some(0x1234));
36 /// ```
37 fn read_i8_rel(&self, address: Option<usize>) -> i8
38 {
39 let mut buffer = [0; 1];
40 self.read_memory_rel(address, &mut buffer);
41 return i8::from_ne_bytes(buffer);
42 }
43
44 /// Relatively read an i32 from an optional offset
45 ///
46 /// # Example
47 ///
48 /// ```
49 /// use mem_rs::prelude::*;
50 ///
51 /// let mut process = Process::new("name_of_process.exe");
52 /// process.refresh()?;
53 /// let pointer = process.create_pointer(0x1234, vec![0]);
54 ///
55 /// let data = pointer.read_i32_rel(Some(0x1234));
56 /// ```
57 fn read_i32_rel(&self, address: Option<usize>) -> i32
58 {
59 let mut buffer = [0; 4];
60 self.read_memory_rel(address, &mut buffer);
61 return i32::from_ne_bytes(buffer);
62 }
63
64 /// Relatively read an i64 from an optional offset
65 ///
66 /// # Example
67 ///
68 /// ```
69 /// use mem_rs::prelude::*;
70 ///
71 /// let mut process = Process::new("name_of_process.exe");
72 /// process.refresh()?;
73 /// let pointer = process.create_pointer(0x1234, vec![0]);
74 ///
75 /// let data = pointer.read_i64_rel(Some(0x1234));
76 /// ```
77 fn read_i64_rel(&self, address: Option<usize>) -> i64
78 {
79 let mut buffer = [0; 8];
80 self.read_memory_rel(address, &mut buffer);
81 return i64::from_ne_bytes(buffer);
82 }
83
84 /// Relatively read an u8 from an optional offset
85 ///
86 /// # Example
87 ///
88 /// ```
89 /// use mem_rs::prelude::*;
90 ///
91 /// let mut process = Process::new("name_of_process.exe");
92 /// process.refresh()?;
93 /// let pointer = process.create_pointer(0x1234, vec![0]);
94 ///
95 /// let data = pointer.read_u8_rel(Some(0x1234));
96 /// ```
97 fn read_u8_rel(&self, address: Option<usize>) -> u8
98 {
99 let mut buffer = [0; 1];
100 self.read_memory_rel(address, &mut buffer);
101 return buffer[0];
102 }
103
104 /// Relatively read an u32 from an optional offset
105 ///
106 /// # Example
107 ///
108 /// ```
109 /// use mem_rs::prelude::*;
110 ///
111 /// let mut process = Process::new("name_of_process.exe");
112 /// process.refresh()?;
113 /// let pointer = process.create_pointer(0x1234, vec![0]);
114 ///
115 /// let data = pointer.read_u32_rel(Some(0x1234));
116 /// ```
117 fn read_u32_rel(&self, address: Option<usize>) -> u32
118 {
119 let mut buffer = [0; 4];
120 self.read_memory_rel(address, &mut buffer);
121 return u32::from_ne_bytes(buffer);
122 }
123
124 /// Relatively read an u64 from an optional offset
125 ///
126 /// # Example
127 ///
128 /// ```
129 /// use mem_rs::prelude::*;
130 ///
131 /// let mut process = Process::new("name_of_process.exe");
132 /// process.refresh()?;
133 /// let pointer = process.create_pointer(0x1234, vec![0]);
134 ///
135 /// let data = pointer.read_u64_rel(Some(0x1234));
136 /// ```
137 fn read_u64_rel(&self, address: Option<usize>) -> u64
138 {
139 let mut buffer = [0; 8];
140 self.read_memory_rel(address, &mut buffer);
141 return u64::from_ne_bytes(buffer);
142 }
143
144 /// Relatively read an f32 from an optional offset
145 ///
146 /// # Example
147 ///
148 /// ```
149 /// use mem_rs::prelude::*;
150 ///
151 /// let mut process = Process::new("name_of_process.exe");
152 /// process.refresh()?;
153 /// let pointer = process.create_pointer(0x1234, vec![0]);
154 ///
155 /// let data = pointer.read_f32_rel(Some(0x1234));
156 /// ```
157 fn read_f32_rel(&self, address: Option<usize>) -> f32
158 {
159 let mut buffer = [0; 4];
160 self.read_memory_rel(address, &mut buffer);
161 return f32::from_ne_bytes(buffer);
162 }
163
164 /// Relatively read an f64 from an optional offset
165 ///
166 /// # Example
167 ///
168 /// ```
169 /// use mem_rs::prelude::*;
170 ///
171 /// let mut process = Process::new("name_of_process.exe");
172 /// process.refresh()?;
173 /// let pointer = process.create_pointer(0x1234, vec![0]);
174 ///
175 /// let data = pointer.read_f64_rel(Some(0x1234));
176 /// ```
177 fn read_f64_rel(&self, address: Option<usize>) -> f64
178 {
179 let mut buffer = [0; 8];
180 self.read_memory_rel(address, &mut buffer);
181 return f64::from_ne_bytes(buffer);
182 }
183
184 /// Relatively read a bool from an optional offset.
185 /// A single byte is read from the resolved address, the value of the bool is true if this byte is non-zero.
186 ///
187 /// # Example
188 ///
189 /// ```
190 /// use mem_rs::prelude::*;
191 ///
192 /// let mut process = Process::new("name_of_process.exe");
193 /// process.refresh()?;
194 /// let pointer = process.create_pointer(0x1234, vec![0]);
195 ///
196 /// let data = pointer.read_bool_rel(Some(0x1234));
197 /// ```
198 fn read_bool_rel(&self, address: Option<usize>) -> bool
199 {
200 let mut buffer = [0; 1];
201 self.read_memory_rel(address, &mut buffer);
202 return buffer[0] != 0;
203 }
204
205
206
207 /// Absolute read an i8 from an address. Ignores offsets. Sugar for read_memory_abs.
208 ///
209 /// # Example
210 ///
211 /// ```
212 /// use mem_rs::prelude::*;
213 ///
214 /// let mut process = Process::new("name_of_process.exe");
215 /// process.refresh()?;
216 /// let pointer = process.create_pointer(0x1234, vec![0]);
217 ///
218 /// let data = pointer.read_i8_abs(0x1234);
219 /// ```
220 fn read_i8_abs(&self, address: usize) -> i8
221 {
222 let mut buffer = [0; 1];
223 self.read_memory_abs(address, &mut buffer);
224 return i8::from_ne_bytes(buffer);
225 }
226
227 /// Absolute read an i32 from an address. Ignores offsets. Sugar for read_memory_abs.
228 ///
229 /// # Example
230 ///
231 /// ```
232 /// use mem_rs::prelude::*;
233 ///
234 /// let mut process = Process::new("name_of_process.exe");
235 /// process.refresh()?;
236 /// let pointer = process.create_pointer(0x1234, vec![0]);
237 ///
238 /// let data = pointer.read_i32_abs(0x1234);
239 /// ```
240 fn read_i32_abs(&self, address: usize) -> i32
241 {
242 let mut buffer = [0; 4];
243 self.read_memory_abs(address, &mut buffer);
244 return i32::from_ne_bytes(buffer);
245 }
246
247 /// Absolute read an i64 from an address. Ignores offsets. Sugar for read_memory_abs.
248 ///
249 /// # Example
250 ///
251 /// ```
252 /// use mem_rs::prelude::*;
253 ///
254 /// let mut process = Process::new("name_of_process.exe");
255 /// process.refresh()?;
256 /// let pointer = process.create_pointer(0x1234, vec![0]);
257 ///
258 /// let data = pointer.read_i64_abs(0x1234);
259 /// ```
260 fn read_i64_abs(&self, address: usize) -> i64
261 {
262 let mut buffer = [0; 8];
263 self.read_memory_abs(address, &mut buffer);
264 return i64::from_ne_bytes(buffer);
265 }
266
267 /// Absolute read an u8 from an address. Ignores offsets. Sugar for read_memory_abs.
268 ///
269 /// # Example
270 ///
271 /// ```
272 /// use mem_rs::prelude::*;
273 ///
274 /// let mut process = Process::new("name_of_process.exe");
275 /// process.refresh()?;
276 /// let pointer = process.create_pointer(0x1234, vec![0]);
277 ///
278 /// let data = pointer.read_u8_abs(0x1234);
279 /// ```
280 fn read_u8_abs(&self, address: usize) -> u8
281 {
282 let mut buffer = [0; 1];
283 self.read_memory_abs(address, &mut buffer);
284 return buffer[0];
285 }
286
287 /// Absolute read an u32 from an address. Ignores offsets. Sugar for read_memory_abs.
288 ///
289 /// # Example
290 ///
291 /// ```
292 /// use mem_rs::prelude::*;
293 ///
294 /// let mut process = Process::new("name_of_process.exe");
295 /// process.refresh()?;
296 /// let pointer = process.create_pointer(0x1234, vec![0]);
297 ///
298 /// let data = pointer.read_u32_abs(0x1234);
299 /// ```
300 fn read_u32_abs(&self, address: usize) -> u32
301 {
302 let mut buffer = [0; 4];
303 self.read_memory_abs(address, &mut buffer);
304 return u32::from_ne_bytes(buffer);
305 }
306
307 /// Absolute read an u64 from an address. Ignores offsets. Sugar for read_memory_abs.
308 ///
309 /// # Example
310 ///
311 /// ```
312 /// use mem_rs::prelude::*;
313 ///
314 /// let mut process = Process::new("name_of_process.exe");
315 /// process.refresh()?;
316 /// let pointer = process.create_pointer(0x1234, vec![0]);
317 ///
318 /// let data = pointer.read_u64_abs(0x1234);
319 /// ```
320 fn read_u64_abs(&self, address: usize) -> u64
321 {
322 let mut buffer = [0; 8];
323 self.read_memory_abs(address, &mut buffer);
324 return u64::from_ne_bytes(buffer);
325 }
326
327 /// Absolute read an f32 from an address. Ignores offsets. Sugar for read_memory_abs.
328 ///
329 /// # Example
330 ///
331 /// ```
332 /// use mem_rs::prelude::*;
333 ///
334 /// let mut process = Process::new("name_of_process.exe");
335 /// process.refresh()?;
336 /// let pointer = process.create_pointer(0x1234, vec![0]);
337 ///
338 /// let data = pointer.read_f32_abs(0x1234);
339 /// ```
340 fn read_f32_abs(&self, address: usize) -> f32
341 {
342 let mut buffer = [0; 4];
343 self.read_memory_abs(address, &mut buffer);
344 return f32::from_ne_bytes(buffer);
345 }
346
347 /// Absolute read an f64 from an address. Ignores offsets. Sugar for read_memory_abs.
348 ///
349 /// # Example
350 ///
351 /// ```
352 /// use mem_rs::prelude::*;
353 ///
354 /// let mut process = Process::new("name_of_process.exe");
355 /// process.refresh()?;
356 /// let pointer = process.create_pointer(0x1234, vec![0]);
357 ///
358 /// let data = pointer.read_f64_abs(0x1234);
359 /// ```
360 fn read_f64_abs(&self, address: usize) -> f64
361 {
362 let mut buffer = [0; 8];
363 self.read_memory_abs(address, &mut buffer);
364 return f64::from_ne_bytes(buffer);
365 }
366
367 /// Absolute read a byte from an address. Ignores offsets. Sugar for read_memory_abs.
368 /// The value of the bool is true if this byte is non-zero.
369 ///
370 /// # Example
371 ///
372 /// ```
373 /// use mem_rs::prelude::*;
374 ///
375 /// let mut process = Process::new("name_of_process.exe");
376 /// process.refresh()?;
377 /// let pointer = process.create_pointer(0x1234, vec![0]);
378 ///
379 /// let data = pointer.read_bool_abs(0x1234);
380 /// ```
381 fn read_bool_abs(&self, address: usize) -> bool
382 {
383 let mut buffer = [0; 1];
384 self.read_memory_abs(address, &mut buffer);
385 return buffer[0] != 0;
386 }
387
388
389
390
391
392
393 //==================================================================================================================================================================
394 //Writing
395
396 /// Relatively write an i8 to an optional offset
397 ///
398 /// # Example
399 ///
400 /// ```
401 /// use mem_rs::prelude::*;
402 ///
403 /// let mut process = Process::new("name_of_process.exe");
404 /// process.refresh()?;
405 /// let pointer = process.create_pointer(0x1234, vec![0]);
406 ///
407 /// let data: i8 = 10;
408 /// pointer.write_i8_rel(Some(0x1234), data);
409 /// ```
410 fn write_i8_rel(&self, address: Option<usize>, value: i8)
411 {
412 let buffer = value.to_ne_bytes();
413 self.write_memory_rel(address, &buffer);
414 }
415
416 /// Relatively write an i32 to an optional offset
417 ///
418 /// # Example
419 ///
420 /// ```
421 /// use mem_rs::prelude::*;
422 ///
423 /// let mut process = Process::new("name_of_process.exe");
424 /// process.refresh()?;
425 /// let pointer = process.create_pointer(0x1234, vec![0]);
426 ///
427 /// let data: i32 = 10;
428 /// pointer.write_i32_rel(Some(0x1234), data);
429 /// ```
430 fn write_i32_rel(&self, address: Option<usize>, value: i32)
431 {
432 let buffer = value.to_ne_bytes();
433 self.write_memory_rel(address, &buffer);
434 }
435
436 /// Relatively write an i64 to an optional offset
437 ///
438 /// # Example
439 ///
440 /// ```
441 /// use mem_rs::prelude::*;
442 ///
443 /// let mut process = Process::new("name_of_process.exe");
444 /// process.refresh()?;
445 /// let pointer = process.create_pointer(0x1234, vec![0]);
446 ///
447 /// let data: i64 = 10;
448 /// pointer.write_i64_rel(Some(0x1234), data);
449 /// ```
450 fn write_i64_rel(&self, address: Option<usize>, value: i64)
451 {
452 let buffer = value.to_ne_bytes();
453 self.write_memory_rel(address, &buffer);
454 }
455
456 /// Relatively write an u8 to an optional offset
457 ///
458 /// # Example
459 ///
460 /// ```
461 /// use mem_rs::prelude::*;
462 ///
463 /// let mut process = Process::new("name_of_process.exe");
464 /// process.refresh()?;
465 /// let pointer = process.create_pointer(0x1234, vec![0]);
466 ///
467 /// let data: u8 = 10;
468 /// pointer.write_u8_rel(Some(0x1234), data);
469 /// ```
470 fn write_u8_rel(&self, address: Option<usize>, value: u8)
471 {
472 let buffer = value.to_ne_bytes();
473 self.write_memory_rel(address, &buffer);
474 }
475
476 /// Relatively write an u32 to an optional offset
477 ///
478 /// # Example
479 ///
480 /// ```
481 /// use mem_rs::prelude::*;
482 ///
483 /// let mut process = Process::new("name_of_process.exe");
484 /// process.refresh()?;
485 /// let pointer = process.create_pointer(0x1234, vec![0]);
486 ///
487 /// let data: u32 = 10;
488 /// pointer.write_u32_rel(Some(0x1234), data);
489 /// ```
490 fn write_u32_rel(&self, address: Option<usize>, value: u32)
491 {
492 let buffer = value.to_ne_bytes();
493 self.write_memory_rel(address, &buffer);
494 }
495
496 /// Relatively write an u64 to an optional offset
497 ///
498 /// # Example
499 ///
500 /// ```
501 /// use mem_rs::prelude::*;
502 ///
503 /// let mut process = Process::new("name_of_process.exe");
504 /// process.refresh()?;
505 /// let pointer = process.create_pointer(0x1234, vec![0]);
506 ///
507 /// let data: u64 = 10;
508 /// pointer.write_u64_rel(Some(0x1234), data);
509 /// ```
510 fn write_u64_rel(&self, address: Option<usize>, value: u64)
511 {
512 let buffer = value.to_ne_bytes();
513 self.write_memory_rel(address, &buffer);
514 }
515
516 /// Relatively write an f32 to an optional offset
517 ///
518 /// # Example
519 ///
520 /// ```
521 /// use mem_rs::prelude::*;
522 ///
523 /// let mut process = Process::new("name_of_process.exe");
524 /// process.refresh()?;
525 /// let pointer = process.create_pointer(0x1234, vec![0]);
526 ///
527 /// let data: f32 = 10.0f32;
528 /// pointer.write_f32_rel(Some(0x1234), data);
529 /// ```
530 fn write_f32_rel(&self, address: Option<usize>, value: f32)
531 {
532 let buffer = value.to_ne_bytes();
533 self.write_memory_rel(address, &buffer);
534 }
535
536 /// Relatively write an f64 to an optional offset
537 ///
538 /// # Example
539 ///
540 /// ```
541 /// use mem_rs::prelude::*;
542 ///
543 /// let mut process = Process::new("name_of_process.exe");
544 /// process.refresh()?;
545 /// let pointer = process.create_pointer(0x1234, vec![0]);
546 ///
547 /// let data: f64 = 10.0f64;
548 /// pointer.write_f64_rel(Some(0x1234), data);
549 /// ```
550 fn write_f64_rel(&self, address: Option<usize>, value: f64)
551 {
552 let buffer = value.to_ne_bytes();
553 self.write_memory_rel(address, &buffer);
554 }
555
556 /// Absolute write an i8
557 ///
558 /// # Example
559 ///
560 /// ```
561 /// use mem_rs::prelude::*;
562 ///
563 /// let mut process = Process::new("name_of_process.exe");
564 /// process.refresh()?;
565 /// let pointer = process.create_pointer(0x1234, vec![0]);
566 ///
567 /// let data: i8 = 10;
568 /// pointer.write_i8_abs(0x1234, data);
569 /// ```
570 fn write_i8_abs(&self, address: usize, value: i8)
571 {
572 let buffer = value.to_ne_bytes();
573 self.write_memory_abs(address, &buffer);
574 }
575
576 /// Absolute write an i32
577 ///
578 /// # Example
579 ///
580 /// ```
581 /// use mem_rs::prelude::*;
582 ///
583 /// let mut process = Process::new("name_of_process.exe");
584 /// process.refresh()?;
585 /// let pointer = process.create_pointer(0x1234, vec![0]);
586 ///
587 /// let data: i32 = 10;
588 /// pointer.write_i32_abs(0x1234, data);
589 /// ```
590 fn write_i32_abs(&self, address: usize, value: i32)
591 {
592 let buffer = value.to_ne_bytes();
593 self.write_memory_abs(address, &buffer);
594 }
595
596 /// Absolute write an i64
597 ///
598 /// # Example
599 ///
600 /// ```
601 /// use mem_rs::prelude::*;
602 ///
603 /// let mut process = Process::new("name_of_process.exe");
604 /// process.refresh()?;
605 /// let pointer = process.create_pointer(0x1234, vec![0]);
606 ///
607 /// let data: i64 = 10;
608 /// pointer.write_i64_abs(0x1234, data);
609 /// ```
610 fn write_i64_abs(&self, address: usize, value: i64)
611 {
612 let buffer = value.to_ne_bytes();
613 self.write_memory_abs(address, &buffer);
614 }
615
616 /// Absolute write an u8
617 ///
618 /// # Example
619 ///
620 /// ```
621 /// use mem_rs::prelude::*;
622 ///
623 /// let mut process = Process::new("name_of_process.exe");
624 /// process.refresh()?;
625 /// let pointer = process.create_pointer(0x1234, vec![0]);
626 ///
627 /// let data: u8 = 10;
628 /// pointer.write_u8_abs(0x1234, data);
629 /// ```
630 fn write_u8_abs(&self, address: usize, value: u8)
631 {
632 let buffer = value.to_ne_bytes();
633 self.write_memory_abs(address, &buffer);
634 }
635
636 /// Absolute write an u32
637 ///
638 /// # Example
639 ///
640 /// ```
641 /// use mem_rs::prelude::*;
642 ///
643 /// let mut process = Process::new("name_of_process.exe");
644 /// process.refresh()?;
645 /// let pointer = process.create_pointer(0x1234, vec![0]);
646 ///
647 /// let data: u32 = 10;
648 /// pointer.write_u32_abs(0x1234, data);
649 /// ```
650 fn write_u32_abs(&self, address: usize, value: u32)
651 {
652 let buffer = value.to_ne_bytes();
653 self.write_memory_abs(address, &buffer);
654 }
655
656 /// Absolute write an u64
657 ///
658 /// # Example
659 ///
660 /// ```
661 /// use mem_rs::prelude::*;
662 ///
663 /// let mut process = Process::new("name_of_process.exe");
664 /// process.refresh()?;
665 /// let pointer = process.create_pointer(0x1234, vec![0]);
666 ///
667 /// let data: u64 = 10;
668 /// pointer.write_u64_abs(0x1234, data);
669 /// ```
670 fn write_u64_abs(&self, address: usize, value: u64)
671 {
672 let buffer = value.to_ne_bytes();
673 self.write_memory_abs(address, &buffer);
674 }
675
676 /// Absolute write an f32
677 ///
678 /// # Example
679 ///
680 /// ```
681 /// use mem_rs::prelude::*;
682 ///
683 /// let mut process = Process::new("name_of_process.exe");
684 /// process.refresh()?;
685 /// let pointer = process.create_pointer(0x1234, vec![0]);
686 ///
687 /// let data: f32 = 10.0f32;
688 /// pointer.write_f32_abs(0x1234, data);
689 /// ```
690 fn write_f32_abs(&self, address: usize, value: f32)
691 {
692 let buffer = value.to_ne_bytes();
693 self.write_memory_abs(address, &buffer);
694 }
695
696 /// Absolute write an f64
697 ///
698 /// # Example
699 ///
700 /// ```
701 /// use mem_rs::prelude::*;
702 ///
703 /// let mut process = Process::new("name_of_process.exe");
704 /// process.refresh()?;
705 /// let pointer = process.create_pointer(0x1234, vec![0]);
706 ///
707 /// let data: f64 = 10.0f64;
708 /// pointer.write_f64_abs(0x1234, data);
709 /// ```
710 fn write_f64_abs(&self, address: usize, value: f64)
711 {
712 let buffer = value.to_ne_bytes();
713 self.write_memory_abs(address, &buffer);
714 }
715}