1use thiserror::Error;
2use windows_sys::Win32::Foundation::{
3 ERROR_ACCESS_DENIED, ERROR_CIRCULAR_DEPENDENCY, ERROR_DATABASE_DOES_NOT_EXIST,
4 ERROR_DUPLICATE_SERVICE_NAME, ERROR_FILE_NOT_FOUND, ERROR_INVALID_HANDLE, ERROR_INVALID_NAME,
5 ERROR_INVALID_PARAMETER, ERROR_INVALID_SERVICE_ACCOUNT, ERROR_PATH_NOT_FOUND,
6 ERROR_SERVICE_ALREADY_RUNNING, ERROR_SERVICE_DATABASE_LOCKED, ERROR_SERVICE_DEPENDENCY_DELETED,
7 ERROR_SERVICE_DEPENDENCY_FAIL, ERROR_SERVICE_DISABLED, ERROR_SERVICE_DOES_NOT_EXIST,
8 ERROR_SERVICE_EXISTS, ERROR_SERVICE_LOGON_FAILED, ERROR_SERVICE_MARKED_FOR_DELETE,
9 ERROR_SERVICE_NOT_ACTIVE, ERROR_SERVICE_NO_THREAD, ERROR_SERVICE_REQUEST_TIMEOUT,
10};
11
12#[derive(Error, Debug)]
13pub enum OpenServiceError {
14 #[error("Access denied: {0}, {1}")]
15 AccessDenied(u32, String),
16 #[error("Invalid handle: {0}, {1}")]
17 InvalidHandle(u32, String),
18 #[error("Invalid name: {0}, {1}")]
19 InvalidName(u32, String),
20 #[error("Service does not exist: {0}, {1}")]
21 ServiceDoesNotExist(u32, String),
22 #[error("Unknown error: {0}, {1}")]
23 Unknown(u32, String),
24}
25
26impl From<(u32, String)> for OpenServiceError {
27 fn from(value: (u32, String)) -> Self {
28 let (err, display) = value;
29 match err {
30 ERROR_ACCESS_DENIED => Self::AccessDenied(err, display),
31 ERROR_INVALID_HANDLE => Self::InvalidHandle(err, display),
32 ERROR_INVALID_NAME => Self::InvalidName(err, display),
33 ERROR_SERVICE_DOES_NOT_EXIST => Self::ServiceDoesNotExist(err, display),
34 _ => Self::Unknown(err, display),
35 }
36 }
37}
38
39#[derive(Error, Debug)]
40pub enum CreateServiceError {
41 #[error("Access denied: {0}, {1}")]
42 AccessDenied(u32, String),
43 #[error("Circular dependency error: {0}, {1}")]
44 CircularDependency(u32, String),
45 #[error("Invalid handle: {0}, {1}")]
46 InvalidHandle(u32, String),
47 #[error("Invalid name: {0}, {1}")]
48 InvalidName(u32, String),
49 #[error("Invalid parameter: {0}, {1}")]
50 InvalidParameter(u32, String),
51 #[error("Invalid service account: {0}, {1}")]
52 InvalidServiceAccount(u32, String),
53 #[error("Service already exists: {0}, {1}")]
54 ServiceExists(u32, String),
55 #[error("Service marked for deletion: {0}, {1}")]
56 ServiceMarkedForDelete(u32, String),
57 #[error("Unknown error: {0}, {1}")]
58 Unknown(u32, String),
59}
60
61impl From<(u32, String)> for CreateServiceError {
62 fn from(value: (u32, String)) -> Self {
63 let (err, display) = value;
64 match err {
65 ERROR_ACCESS_DENIED => Self::AccessDenied(err, display),
66 ERROR_CIRCULAR_DEPENDENCY => Self::CircularDependency(err, display),
67 ERROR_DUPLICATE_SERVICE_NAME => Self::ServiceExists(err, display),
68 ERROR_INVALID_HANDLE => Self::InvalidHandle(err, display),
69 ERROR_INVALID_NAME => Self::InvalidName(err, display),
70 ERROR_INVALID_PARAMETER => Self::InvalidParameter(err, display),
71 ERROR_INVALID_SERVICE_ACCOUNT => Self::InvalidServiceAccount(err, display),
72 ERROR_SERVICE_EXISTS => Self::ServiceExists(err, display),
73 ERROR_SERVICE_MARKED_FOR_DELETE => Self::ServiceMarkedForDelete(err, display),
74 _ => Self::Unknown(err, display),
75 }
76 }
77}
78
79#[derive(Error, Debug)]
80pub enum ServiceManagerError {
81 #[error("Access denied: {0}, {1}")]
82 AccessDenied(u32, String),
83 #[error("Circular dependency error: {0}, {1}")]
84 DatabaseDoesNotExist(u32, String),
85 #[error("Invalid Service Manager handle: {0}, {1}")]
86 InvalidHandle(u32, String),
87 #[error("Unknown error: {0}, {1}")]
88 Unknown(u32, String),
89}
90
91impl From<(u32, String)> for ServiceManagerError {
92 fn from(value: (u32, String)) -> Self {
93 let (err, display) = value;
94 match err {
95 ERROR_ACCESS_DENIED => Self::AccessDenied(err, display),
96 ERROR_DATABASE_DOES_NOT_EXIST => Self::DatabaseDoesNotExist(err, display),
97 ERROR_INVALID_HANDLE => Self::DatabaseDoesNotExist(err, display),
98 _ => Self::Unknown(err, display),
99 }
100 }
101}
102#[derive(Error, Debug)]
103pub enum ControlServiceError {
104 #[error("Access denied: {0}, {1}")]
105 AccessDenied(u32, String),
106 #[error("Invalid handle: {0}, {1}")]
107 InvalidHandle(u32, String),
108 #[error("Path not found: {0}, {1}")]
109 PathNotFound(u32, String),
110 #[error("Service already running: {0}, {1}")]
111 ServiceAlreadyRunning(u32, String),
112 #[error("Service not active: {0}, {1}")]
113 ServiceNotActive(u32, String),
114 #[error("Service database locked: {0}, {1}")]
115 ServiceDatabaseLocked(u32, String),
116 #[error("Service dependency deleted: {0}, {1}")]
117 ServiceDependencyDeleted(u32, String),
118 #[error("Service dependency failed: {0}, {1}")]
119 ServiceDependencyFail(u32, String),
120 #[error("Service disabled: {0}, {1}")]
121 ServiceDisabled(u32, String),
122 #[error("Service logon failed: {0}, {1}")]
123 ServiceLogonFailed(u32, String),
124 #[error("Service marked for deletion: {0}, {1}")]
125 ServiceMarkedForDelete(u32, String),
126 #[error("Service no thread: {0}, {1}")]
127 ServiceNoThread(u32, String),
128 #[error("Service request timeout: {0}, {1}")]
129 ServiceRequestTimeout(u32, String),
130 #[error("Unknown error: {0}, {1}")]
131 Unknown(u32, String),
132}
133
134impl From<(u32, String)> for ControlServiceError {
135 fn from(value: (u32, String)) -> Self {
136 let (err, display) = value;
137 match err {
138 ERROR_ACCESS_DENIED => Self::AccessDenied(err, display),
139 ERROR_INVALID_HANDLE => Self::InvalidHandle(err, display),
140 ERROR_PATH_NOT_FOUND | ERROR_FILE_NOT_FOUND => Self::PathNotFound(err, display),
141 ERROR_SERVICE_ALREADY_RUNNING => Self::ServiceAlreadyRunning(err, display),
142 ERROR_SERVICE_NOT_ACTIVE => Self::ServiceNotActive(err, display),
143 ERROR_SERVICE_DATABASE_LOCKED => Self::ServiceDatabaseLocked(err, display),
144 ERROR_SERVICE_DEPENDENCY_DELETED => Self::ServiceDependencyDeleted(err, display),
145 ERROR_SERVICE_DEPENDENCY_FAIL => Self::ServiceDependencyFail(err, display),
146 ERROR_SERVICE_DISABLED => Self::ServiceDisabled(err, display),
147 ERROR_SERVICE_LOGON_FAILED => Self::ServiceLogonFailed(err, display),
148 ERROR_SERVICE_MARKED_FOR_DELETE => Self::ServiceMarkedForDelete(err, display),
149 ERROR_SERVICE_NO_THREAD => Self::ServiceNoThread(err, display),
150 ERROR_SERVICE_REQUEST_TIMEOUT => Self::ServiceRequestTimeout(err, display),
151 _ => Self::Unknown(err, display),
152 }
153 }
154}
155
156#[derive(Error, Debug)]
157pub enum DeleteServiceError {
158 #[error("Access denied: {0}, {1}")]
159 AccessDenied(u32, String),
160 #[error("The specified service has already been marked for deletion: {0}, {1}")]
161 ErrorServiceMarkedForDelete(u32, String),
162 #[error("Invalid handle: {0}, {1}")]
163 InvalidHandle(u32, String),
164 #[error("Unknown error: {0}, {1}")]
165 Unknown(u32, String),
166}
167
168impl From<(u32, String)> for DeleteServiceError {
169 fn from(value: (u32, String)) -> Self {
170 let (err, display) = value;
171 match err {
172 ERROR_ACCESS_DENIED => Self::AccessDenied(err, display),
173 ERROR_SERVICE_MARKED_FOR_DELETE => Self::ErrorServiceMarkedForDelete(err, display),
174 ERROR_INVALID_HANDLE => Self::InvalidHandle(err, display),
175 _ => Self::Unknown(err, display),
176 }
177 }
178}
179
180
181#[derive(Error, Debug)]
182pub enum UpdateServiceError {
183 #[error("Access denied: {0}, {1}")]
184 AccessDenied(u32, String),
185 #[error("Circular dependency error: {0}, {1}")]
186 CircularDependency(u32, String),
187 #[error("Duplicate service name: {0}, {1}")]
188 DuplicateServiceName(u32, String),
189 #[error("Invalid handle: {0}, {1}")]
190 InvalidHandle(u32, String),
191 #[error("Invalid parameter: {0}, {1}")]
192 InvalidParameter(u32, String),
193 #[error("Invalid service account: {0}, {1}")]
194 InvalidServiceAccount(u32, String),
195 #[error("Service marked for deletion: {0}, {1}")]
196 ServiceMarkedForDelete(u32, String),
197 #[error("Unknown error: {0}, {1}")]
198 Unknown(u32, String),
199}
200
201impl From<(u32, String)> for UpdateServiceError {
202 fn from(value: (u32, String)) -> Self {
203 let (err, display) = value;
204 match err {
205 ERROR_ACCESS_DENIED => Self::AccessDenied(err, display),
206 ERROR_CIRCULAR_DEPENDENCY => Self::CircularDependency(err, display),
207 ERROR_DUPLICATE_SERVICE_NAME => Self::DuplicateServiceName(err, display),
208 ERROR_INVALID_HANDLE => Self::InvalidHandle(err, display),
209 ERROR_INVALID_PARAMETER => Self::InvalidParameter(err, display),
210 ERROR_INVALID_SERVICE_ACCOUNT => Self::InvalidServiceAccount(err, display),
211 ERROR_SERVICE_MARKED_FOR_DELETE => Self::ServiceMarkedForDelete(err, display),
212 _ => Self::Unknown(err, display),
213 }
214 }
215}
216
217
218#[derive(Error, Debug)]
219pub enum QueryServiceError {
220 #[error("Access denied: {0}, {1}")]
221 AccessDenied(u32, String),
222 #[error("Invalid service handle: {0}, {1}")]
223 InvalidHandle(u32, String),
224 #[error("Unknown error: {0}, {1}")]
225 Unknown(u32, String),
226}
227
228impl From<(u32, String)> for QueryServiceError {
229 fn from(value: (u32, String)) -> Self {
230 let (err, display) = value;
231 match err {
232 ERROR_ACCESS_DENIED => Self::AccessDenied(err, display),
233 ERROR_INVALID_HANDLE => Self::InvalidHandle(err, display),
234 _ => Self::Unknown(err, display),
235 }
236 }
237}