dnp3 1.6.0

Rust implementation of DNP3 (IEEE 1815) with idiomatic bindings for C, C++, .NET, and Java
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

use crate::app::format::write::HeaderWriter;
use crate::app::format::WriteError;
use crate::app::parse::free_format::FreeFormatVariation;
use crate::app::parse::parser::{HeaderDetails, Response};
use crate::app::{FileStatus, FunctionCode, Group70Var3, Permissions, Timestamp};
use crate::master::promise::Promise;
use crate::master::tasks::file::REQUEST_ID;
use crate::master::tasks::{AppTask, NonReadTask, Task};
use crate::master::{AuthKey, FileError, FileHandle, FileMode, OpenFile, TaskError};
pub(crate) struct OpenFileRequest {
    pub(crate) file_name: String,
    pub(crate) auth_key: AuthKey,
    pub(crate) file_size: u32,
    pub(crate) file_mode: FileMode,
    pub(crate) permissions: Permissions,
    pub(crate) max_block_size: u16,
}

pub(crate) struct OpenFileTask {
    pub(crate) request: OpenFileRequest,
    pub(crate) promise: Promise<Result<OpenFile, FileError>>,
}

impl From<OpenFileTask> for Task {
    fn from(value: OpenFileTask) -> Self {
        Task::App(AppTask::NonRead(NonReadTask::OpenFile(value)))
    }
}

impl OpenFileTask {
    pub(crate) fn function(&self) -> FunctionCode {
        FunctionCode::OpenFile
    }

    pub(crate) fn write(&self, writer: &mut HeaderWriter) -> Result<(), WriteError> {
        let obj = Group70Var3 {
            time_of_creation: Timestamp::zero(),
            permissions: self.request.permissions,
            auth_key: self.request.auth_key.into(),
            file_size: self.request.file_size,
            mode: self.request.file_mode,
            max_block_size: self.request.max_block_size,
            request_id: REQUEST_ID,
            file_name: &self.request.file_name,
        };

        writer.write_free_format(&obj)
    }

    pub(crate) fn on_task_error(self, err: TaskError) {
        self.promise.complete(Err(err.into()))
    }

    pub(crate) fn handle(self, response: Response<'_>) -> Result<Option<NonReadTask>, TaskError> {
        fn process(response: Response<'_>) -> Result<OpenFile, FileError> {
            let header = response.objects?.get_only_header()?;

            let obj = match header.details {
                HeaderDetails::TwoByteFreeFormat(_, FreeFormatVariation::Group70Var4(obj)) => obj,
                _ => {
                    tracing::warn!(
                        "File OPEN response contains unexpected variation: {}",
                        header.variation
                    );
                    return Err(FileError::BadResponse);
                }
            };

            if obj.status_code != FileStatus::Success {
                tracing::warn!("Unable to open file (status code == {:?})", obj.status_code);
                return Err(FileError::BadStatus(obj.status_code));
            }

            Ok(OpenFile {
                max_block_size: obj.max_block_size,
                file_handle: FileHandle::new(obj.file_handle),
                file_size: obj.file_size,
            })
        }

        let result = process(response);
        self.promise.complete(result);

        match result {
            Ok(_) => Ok(None),
            Err(err) => Err(err.into()),
        }
    }
}