1 krisbash 1.1 #include "omierror.h"
2 #include "OMI_Error.h"
3 #include <pal/strings.h>
4 #include <base/instance.h>
5 #include <pal/format.h>
6 #include <base/result.h>
7 #include <pal/atomic.h>
8 #include "strid_errors.h"
9 #include <errno.h>
10
11 extern MI_CONST MI_ClassDecl OMI_Error_rtti;
12
13 MI_INLINE MI_ErrorCategory ErrorCategoryFromMIResult(MI_Uint32 error)
14 {
15 MI_ErrorCategory miCategory = MI_ERRORCATEGORY_NOT_SPECIFIED;
16 switch(error)
17 {
18 case MI_RESULT_OK :
19 miCategory = MI_ERRORCATEGORY_NOT_SPECIFIED;
20 break;
21 case MI_RESULT_FAILED :
22 krisbash 1.1 miCategory = MI_ERRORCATEGORY_NOT_SPECIFIED;
23 break;
24 case MI_RESULT_ACCESS_DENIED :
25 miCategory = MI_ERRORCATEGORY_ACCESS_DENIED;
26 break;
27 case MI_RESULT_INVALID_NAMESPACE :
28 miCategory = MI_ERRORCATEGORY_METADATA_ERROR;
29 break;
30 case MI_RESULT_INVALID_PARAMETER :
31 miCategory = MI_ERRORCATEGORY_INVALID_ARGUMENT;
32 break;
33 case MI_RESULT_INVALID_CLASS :
34 miCategory = MI_ERRORCATEGORY_METADATA_ERROR;
35 break;
36 case MI_RESULT_NOT_FOUND :
37 miCategory = MI_ERRORCATEGORY_OBJECT_NOT_FOUND;
38 break;
39 case MI_RESULT_NOT_SUPPORTED :
40 miCategory = MI_ERRORCATEGORY_NOT_IMPLEMENTED;
41 break;
42 case MI_RESULT_CLASS_HAS_CHILDREN :
43 krisbash 1.1 miCategory = MI_ERRORCATEGORY_METADATA_ERROR;
44 break;
45 case MI_RESULT_CLASS_HAS_INSTANCES :
46 miCategory = MI_ERRORCATEGORY_METADATA_ERROR;
47 break;
48 case MI_RESULT_INVALID_SUPERCLASS :
49 miCategory = MI_ERRORCATEGORY_METADATA_ERROR;
50 break;
51 case MI_RESULT_ALREADY_EXISTS :
52 miCategory = MI_ERRORCATEGORY_RESOURCE_EXISTS;
53 break;
54 case MI_RESULT_NO_SUCH_PROPERTY :
55 miCategory = MI_ERRORCATEGORY_METADATA_ERROR;
56 break;
57 case MI_RESULT_TYPE_MISMATCH :
58 miCategory = MI_ERRORCATEGORY_INVALID_TYPE;
59 break;
60 case MI_RESULT_QUERY_LANGUAGE_NOT_SUPPORTED :
61 miCategory = MI_ERRORCATEGORY_NOT_IMPLEMENTED;
62 break;
63 case MI_RESULT_INVALID_QUERY :
64 krisbash 1.1 miCategory = MI_ERRORCATEGORY_INVALID_ARGUMENT;
65 break;
66 case MI_RESULT_METHOD_NOT_AVAILABLE :
67 miCategory = MI_ERRORCATEGORY_METADATA_ERROR;
68 break;
69 case MI_RESULT_METHOD_NOT_FOUND :
70 miCategory = MI_ERRORCATEGORY_METADATA_ERROR;
71 break;
72 case MI_RESULT_NAMESPACE_NOT_EMPTY :
73 miCategory = MI_ERRORCATEGORY_METADATA_ERROR;
74 break;
75 case MI_RESULT_INVALID_ENUMERATION_CONTEXT :
76 miCategory = MI_ERRORCATEGORY_METADATA_ERROR;
77 break;
78 case MI_RESULT_INVALID_OPERATION_TIMEOUT :
79 miCategory = MI_ERRORCATEGORY_INVALID_ARGUMENT;
80 break;
81 case MI_RESULT_PULL_HAS_BEEN_ABANDONED :
82 miCategory = MI_ERRORCATEGORY_OPERATION_STOPPED;
83 break;
84 case MI_RESULT_PULL_CANNOT_BE_ABANDONED :
85 krisbash 1.1 miCategory = MI_ERRORCATEGORY_CLOS_EERROR;
86 break;
87 case MI_RESULT_FILTERED_ENUMERATION_NOT_SUPPORTED :
88 miCategory = MI_ERRORCATEGORY_NOT_IMPLEMENTED;
89 break;
90 case MI_RESULT_CONTINUATION_ON_ERROR_NOT_SUPPORTED :
91 miCategory = MI_ERRORCATEGORY_NOT_IMPLEMENTED;
92 break;
93 case MI_RESULT_SERVER_LIMITS_EXCEEDED :
94 miCategory = MI_ERRORCATEGORY_RESOURCE_BUSY;
95 break;
96 case MI_RESULT_SERVER_IS_SHUTTING_DOWN :
97 miCategory = MI_ERRORCATEGORY_RESOURCE_UNAVAILABLE;
98 break;
99 default:
100 miCategory = MI_ERRORCATEGORY_NOT_SPECIFIED;
101 break;
102 }
103 return miCategory;
104 }
105
106 krisbash 1.1 const ZChar* MiResult_ToString(MI_Result result, _Out_writes_z_(len) MI_Char *buffer, MI_Uint32 len)
107 {
108 size_t i;
109 struct Pair
110 {
111 MI_Result result;
112 #if defined (_MSC_VER)
113 MI_Uint32 str;
114 #else
115 const ZChar* str;
116 #endif
117 };
118 #if defined (_MSC_VER)
119 MI_Uint32 str = 0;
120 #else
121 const ZChar* str = NULL;
122 #endif
123 static struct Pair _pairs[] =
124 {
125 { MI_RESULT_OK, STRID_MI_RESULT_OK },
126 { MI_RESULT_FAILED, STRID_MI_RESULT_FAILED },
127 krisbash 1.1 { MI_RESULT_ACCESS_DENIED, STRID_MI_RESULT_ACCESS_DENIED },
128 { MI_RESULT_INVALID_NAMESPACE, STRID_MI_RESULT_INVALID_NAMESPACE },
129 { MI_RESULT_INVALID_PARAMETER, STRID_MI_RESULT_INVALID_PARAMETER },
130 { MI_RESULT_INVALID_CLASS, STRID_MI_RESULT_INVALID_CLASS },
131 { MI_RESULT_NOT_FOUND, STRID_MI_RESULT_NOT_FOUND },
132 { MI_RESULT_NOT_SUPPORTED, STRID_MI_RESULT_NOT_SUPPORTED },
133 { MI_RESULT_CLASS_HAS_CHILDREN, STRID_MI_RESULT_CLASS_HAS_CHILDREN },
134 { MI_RESULT_CLASS_HAS_INSTANCES, STRID_MI_RESULT_CLASS_HAS_INSTANCES },
135 { MI_RESULT_INVALID_SUPERCLASS, STRID_MI_RESULT_INVALID_SUPERCLASS },
136 { MI_RESULT_ALREADY_EXISTS, STRID_MI_RESULT_ALREADY_EXISTS },
137 { MI_RESULT_NO_SUCH_PROPERTY, STRID_MI_RESULT_NO_SUCH_PROPERTY },
138 { MI_RESULT_TYPE_MISMATCH, STRID_MI_RESULT_TYPE_MISMATCH },
139 { MI_RESULT_QUERY_LANGUAGE_NOT_SUPPORTED, STRID_MI_RESULT_QUERY_LANGUAGE_NOT_SUPPORTED },
140 { MI_RESULT_INVALID_QUERY, STRID_MI_RESULT_INVALID_QUERY },
141 { MI_RESULT_METHOD_NOT_AVAILABLE, STRID_MI_RESULT_METHOD_NOT_AVAILABLE },
142 { MI_RESULT_METHOD_NOT_FOUND, STRID_MI_RESULT_METHOD_NOT_FOUND },
143 { MI_RESULT_NAMESPACE_NOT_EMPTY, STRID_MI_RESULT_NAMESPACE_NOT_EMPTY },
144 { MI_RESULT_INVALID_ENUMERATION_CONTEXT, STRID_MI_RESULT_INVALID_ENUMERATION_CONTEXT },
145 { MI_RESULT_INVALID_OPERATION_TIMEOUT, STRID_MI_RESULT_INVALID_OPERATION_TIMEOUT },
146 { MI_RESULT_PULL_HAS_BEEN_ABANDONED, STRID_MI_RESULT_PULL_HAS_BEEN_ABANDONED },
147 { MI_RESULT_PULL_CANNOT_BE_ABANDONED, STRID_MI_RESULT_PULL_CANNOT_BE_ABANDONED },
148 krisbash 1.1 { MI_RESULT_FILTERED_ENUMERATION_NOT_SUPPORTED, STRID_MI_RESULT_FILTERED_ENUMERATION_NOT_SUPPORTED },
149 { MI_RESULT_CONTINUATION_ON_ERROR_NOT_SUPPORTED, STRID_MI_RESULT_CONTINUATION_ON_ERROR_NOT_SUPPORTED },
150 { MI_RESULT_SERVER_LIMITS_EXCEEDED, STRID_MI_RESULT_SERVER_LIMITS_EXCEEDED },
151 { MI_RESULT_SERVER_IS_SHUTTING_DOWN, STRID_MI_RESULT_SERVER_IS_SHUTTING_DOWN },
152 { MI_RESULT_CANCELED, STRID_MI_RESULT_CANCELED },
153 { MI_RESULT_OPEN_FAILED, STRID_MI_RESULT_OPEN_FAILED },
154 { MI_RESULT_INVALID_CLASS_HIERARCHY, STRID_MI_RESULT_INVALID_CLASS_HIERARCHY },
155 { MI_RESULT_WOULD_BLOCK, STRID_MI_RESULT_WOULD_BLOCK },
156 { MI_RESULT_TIME_OUT, STRID_MI_RESULT_TIME_OUT },
157 };
158
159 for (i = 0; i < MI_COUNT(_pairs); i++)
160 {
161 if (result == _pairs[i].result)
162 {
163 str = _pairs[i].str;
164 break;
165 }
166 }
167
168 buffer[0] = 0;
169 krisbash 1.1
170 if (str == 0)
171 {
172 /* Not found! */
173 return MI_T("");
174 }
175
176 #if defined (_MSC_VER)
177 {
178 static HINSTANCE hInstance = 0;
179 if (hInstance == 0)
180 {
181 if (GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS|GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, (LPWSTR)MiResult_ToString, &hInstance) == 0)
182 return MI_T("");
183 }
184 if (LoadStringW(hInstance, str, buffer, len) == 0)
185 return MI_T("");
186
187 return buffer;
188 }
189 #else
190 krisbash 1.1 return str;
191 #endif
192 }
193
194 _Success_(return == MI_RESULT_OK)
195 MI_Result OmiErrorFromMiCode(
196 _In_opt_ Batch* batch,
197 MI_Uint32 OMI_Code,
198 _In_z_ const MI_Char* Message,
199 _Outptr_opt_result_maybenull_ OMI_Error **omiError)
200 {
201 MI_Result miResult;
202 MI_Char messageId[100];
203 MI_Char buffer[100];
204 const MI_Char *errorMessage;
205
206 if(omiError == NULL)
207 return MI_RESULT_OK;
208
209 *omiError = NULL;
210
211 krisbash 1.1 if (OMI_Code == MI_RESULT_OK)
212 {
213 return MI_RESULT_OK;
214 }
215
216 miResult = Instance_New((MI_Instance**)omiError, &OMI_Error_rtti, batch);
217 if (miResult != MI_RESULT_OK)
218 return miResult;
219
220 errorMessage = MiResult_ToString((MI_Result)OMI_Code, buffer, sizeof(buffer)/sizeof(buffer[0]));
221
222 if (Message == NULL)
223 Message = errorMessage;
224
225 Stprintf(messageId, sizeof(messageId)/sizeof(messageId[0]), PAL_T("OMI:MI_Result:%d"), OMI_Code);
226
227 if (
228 ((miResult = OMI_Error_Set_CIMStatusCode(*omiError, OMI_Code)) == MI_RESULT_OK) &&
229 ((miResult = OMI_Error_Set_Message(*omiError, Message)) == MI_RESULT_OK) &&
230 ((miResult = OMI_Error_Set_MessageArguments(*omiError, NULL, 0)) == MI_RESULT_OK) &&
231 ((miResult = OMI_Error_Set_MessageID(*omiError, messageId)) == MI_RESULT_OK) &&
232 krisbash 1.1 ((miResult = OMI_Error_Set_OMI_Category(*omiError, ErrorCategoryFromMIResult(OMI_Code))) == MI_RESULT_OK) &&
233 ((miResult = OMI_Error_Set_OMI_Code(*omiError, OMI_Code)) == MI_RESULT_OK) &&
234 ((miResult = OMI_Error_Set_OMI_ErrorMessage(*omiError, errorMessage)) == MI_RESULT_OK) &&
235 ((miResult = OMI_Error_Set_OMI_Type(*omiError, MI_RESULT_TYPE_MI)) == MI_RESULT_OK) &&
236 ((miResult = OMI_Error_Set_OwningEntity(*omiError, PAL_T("OMI:CIMOM"))) == MI_RESULT_OK) &&
237 ((miResult = OMI_Error_Set_PerceivedSeverity(*omiError, 7)) == MI_RESULT_OK) &&
238 ((miResult = OMI_Error_Set_ProbableCause(*omiError, 0)) == MI_RESULT_OK) &&
239 ((miResult = OMI_Error_Set_ProbableCauseDescription(*omiError, PAL_T("Unknown"))) == MI_RESULT_OK)
240 )
241 {
242 }
243 return miResult;
244 }
245
246
247 MI_Result MIResultFromErrno(MI_Uint32 errorCode)
248 {
249 MI_Result miResult;
250
251 switch(errorCode)
252 {
253 krisbash 1.1 case EINVAL:
254 miResult = MI_RESULT_INVALID_PARAMETER;
255 break;
256 case EACCES:
257 miResult = MI_RESULT_ACCESS_DENIED;
258 break;
259 case ENOMEM:
260 miResult = MI_RESULT_SERVER_LIMITS_EXCEEDED;
261 break;
262 default:
263 miResult = MI_RESULT_FAILED;
264 break;
265 }
266 return miResult;
267 }
268 MI_INLINE MI_ErrorCategory ErrorCategoryFromErrno(MI_Uint32 error)
269 {
270 return ErrorCategoryFromMIResult(MIResultFromErrno(error));
271 }
272
273 #if defined(CONFIG_HAVE_STRERROR_R)
274 krisbash 1.1 MI_INLINE const MI_Char *Errno_ToString(
275 MI_Uint32 OMI_Code,
276 _Out_writes_z_(len) MI_Char *buffer,
277 MI_Uint32 len)
278 {
279 # if defined(CONFIG_ENABLE_WCHAR)
280 {
281 char buf[128];
282 char* str;
283
284 if (len > MI_COUNT(buf))
285 {
286 if (!(str = (char*)PAL_Malloc(len)))
287 return MI_T("");
288 }
289 else
290 {
291 str = buf;
292 }
293
294
295 krisbash 1.1 *str = '\0';
296 strerror_r(OMI_Code, str, len);
297 TcsStrlcpy(buffer, str, len);
298
299 if (str != buf)
300 PAL_Free(str);
301
302 return buffer;
303 }
304 # else /* defined(CONFIG_ENABLE_WCHAR) */
305 {
306 *buffer = '\0';
307 strerror_r(OMI_Code, buffer, len);
308 return buffer;
309 }
310 # endif /* defined(CONFIG_ENABLE_WCHAR) */
311 }
312 #endif /* defined(CONFIG_HAVE_STRERROR_R) */
313
314 #if !defined(CONFIG_HAVE_STRERROR_R)
315 MI_INLINE const MI_Char *Errno_ToString(MI_Uint32 OMI_Code, _Out_writes_z_(len) MI_Char *buffer, MI_Uint32 len)
316 krisbash 1.1 {
317 size_t i;
318 struct Pair
319 {
320 MI_Uint32 result;
321 #if defined (_MSC_VER)
322 MI_Uint32 str;
323 #else
324 const ZChar* str;
325 #endif
326 };
327 #if defined (_MSC_VER)
328 MI_Uint32 str = 0;
329 #else
330 const ZChar* str = NULL;
331 #endif
332 static struct Pair _pairs[] =
333 {
334 { EPERM, STRID_EPERM },
335 { ENOENT, STRID_ENOENT },
336 { ESRCH, STRID_ESRCH },
337 krisbash 1.1 { EINTR, STRID_EINTR },
338 { EIO, STRID_EIO },
339 { ENXIO, STRID_ENXIO },
340 { E2BIG, STRID_E2BIG },
341 { ENOEXEC, STRID_ENOEXEC },
342 { EBADF, STRID_EBADF },
343 { ECHILD, STRID_ECHILD },
344 { EAGAIN, STRID_EAGAIN },
345 { ENOMEM, STRID_ENOMEM },
346 { EACCES, STRID_EACCES },
347 { EFAULT, STRID_EFAULT },
348 { EBUSY, STRID_EBUSY },
349 { EEXIST, STRID_EEXIST },
350 { EXDEV, STRID_EXDEV },
351 { ENODEV, STRID_ENODEV },
352 { ENOTDIR, STRID_ENOTDIR },
353 { EISDIR, STRID_EISDIR },
354 { EINVAL, STRID_EINVAL },
355 { ENFILE, STRID_ENFILE },
356 { EMFILE, STRID_EMFILE },
357 { ENOTTY, STRID_ENOTTY },
358 krisbash 1.1 { EFBIG, STRID_EFBIG },
359 { ENOSPC, STRID_ENOSPC },
360 { ESPIPE, STRID_ESPIPE },
361 { EROFS, STRID_EROFS },
362 { EMLINK, STRID_EMLINK },
363 { EPIPE, STRID_EPIPE },
364 { EDOM, STRID_EDOM },
365 { ERANGE, STRID_ERANGE },
366 { EDEADLK, STRID_EDEADLK },
367 { ENAMETOOLONG, STRID_ENAMETOOLONG },
368 { ENOLCK, STRID_ENOLCK },
369 { ENOSYS, STRID_ENOSYS },
370 { EILSEQ, STRID_EILSEQ },
371 #if defined (_MSC_VER)
372 { STRUNCATE, STRID_STRUNCATE }
373 #endif
374 };
375
376 for (i = 0; i < MI_COUNT(_pairs); i++)
377 {
378 if (OMI_Code == _pairs[i].result)
379 krisbash 1.1 {
380 str = _pairs[i].str;
381 break;
382 }
383 }
384
385 buffer[0] = 0;
386
387 if (str == 0)
388 {
389 /* Not found! */
390 return MI_T("");
391 }
392
393 #if defined (_MSC_VER)
394 {
395 static HINSTANCE hInstance = 0;
396 if (hInstance == 0)
397 {
398 if (GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS|GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, (LPWSTR)Errno_ToString, &hInstance) == 0)
399 return MI_T("");
400 krisbash 1.1 }
401 if (LoadStringW(hInstance, str, buffer, len) == 0)
402 return MI_T("");
403
404 return buffer;
405 }
406 #else
407 return str;
408 #endif
409 }
410 #endif /* !defined(CONFIG_HAVE_STRERROR_R) */
411
412 _Success_(return == MI_RESULT_OK)
413 MI_Result OmiErrorFromErrno(
414 _In_opt_ Batch* batch,
415 MI_Uint32 OMI_Code,
416 _In_z_ const MI_Char* Message,
417 _Outptr_opt_result_maybenull_ OMI_Error **omiError)
418 {
419 MI_Result miResult;
420 MI_Char messageId[100];
421 krisbash 1.1 MI_Char buffer[100];
422 const MI_Char *errorMessage;
423
424 if (omiError == NULL)
425 return MI_RESULT_OK;
426
427 *omiError = NULL;
428
429 if (OMI_Code == 0)
430 return MI_RESULT_OK;
431
432 miResult = Instance_New((MI_Instance**)omiError, &OMI_Error_rtti, batch);
433 if (miResult != MI_RESULT_OK)
434 return miResult;
435
436 errorMessage = Errno_ToString(OMI_Code, buffer, sizeof(buffer)/sizeof(buffer[0]));
437
438 if (Message == NULL)
439 Message = errorMessage;
440
441 Stprintf(messageId, sizeof(messageId)/sizeof(messageId[0]), PAL_T("CRT errno %d"), OMI_Code);
442 krisbash 1.1
443 if (((miResult = OMI_Error_Set_OMI_Code(*omiError, OMI_Code)) == MI_RESULT_OK) &&
444 ((miResult = OMI_Error_Set_OMI_Type(*omiError, MI_T("ERRNO"))) == MI_RESULT_OK) &&
445 ((miResult = OMI_Error_Set_Message(*omiError, Message)) == MI_RESULT_OK) &&
446 ((miResult = OMI_Error_Set_MessageArguments(*omiError, NULL, 0)) == MI_RESULT_OK) &&
447 ((miResult = OMI_Error_Set_OMI_ErrorMessage(*omiError, errorMessage)) == MI_RESULT_OK) &&
448 ((miResult = OMI_Error_Set_OMI_Category(*omiError, ErrorCategoryFromErrno(OMI_Code))) == MI_RESULT_OK) &&
449 ((miResult = OMI_Error_Set_CIMStatusCode(*omiError, MIResultFromErrno(OMI_Code))) == MI_RESULT_OK) &&
450 ((miResult = OMI_Error_Set_MessageID(*omiError, messageId)) == MI_RESULT_OK) &&
451 ((miResult = OMI_Error_Set_OwningEntity(*omiError, PAL_T("OMI:CIMOM"))) == MI_RESULT_OK) &&
452 ((miResult = OMI_Error_Set_PerceivedSeverity(*omiError, 7)) == MI_RESULT_OK) &&
453 ((miResult = OMI_Error_Set_ProbableCause(*omiError, 0)) == MI_RESULT_OK) &&
454 ((miResult = OMI_Error_Set_ProbableCauseDescription(*omiError, PAL_T("Unknown"))) == MI_RESULT_OK))
455 {
456 }
457 return miResult;
458 }
459
460 #if defined(_MSC_VER)
461
462 MI_INLINE MI_ErrorCategory ErrorCategoryFromWin32Error(MI_Uint32 error)
463 krisbash 1.1 {
464 MI_ErrorCategory miCategory;
465 switch(error)
466 {
467 case ERROR_GEN_FAILURE:
468 default:
469 miCategory = MI_ERRORCATEGORY_NOT_SPECIFIED;
470 break;
471 case ERROR_INVALID_PARAMETER:
472 miCategory = MI_ERRORCATEGORY_INVALID_ARGUMENT;
473 break;
474 case ERROR_INVALID_HANDLE:
475 case ERROR_INVALID_DATA:
476 case ERROR_BAD_PATHNAME:
477 case ERROR_INVALID_ADDRESS:
478 case DNS_ERROR_INVALID_IP_ADDRESS:
479 miCategory = MI_ERRORCATEGORY_INVALID_DATA;
480 break;
481 case ERROR_NOT_SUPPORTED:
482 case ERROR_CANNOT_COPY:
483 case ERROR_CAN_NOT_COMPLETE:
484 krisbash 1.1 case ERROR_CANTWRITE:
485 miCategory = MI_ERRORCATEGORY_INVALID_OPERATION;
486 break;
487 case ERROR_BAD_CONFIGURATION:
488 miCategory = MI_ERRORCATEGORY_INVALID_RESULT;
489 break;
490
491 case ERROR_FILE_NOT_FOUND:
492 case ERROR_PATH_NOT_FOUND:
493 case ERROR_PROC_NOT_FOUND:
494 case ERROR_NO_DATA:
495 case ERROR_NOINTERFACE:
496 case ERROR_SERVICE_DOES_NOT_EXIST:
497 case ERROR_NOT_FOUND:
498 case ERROR_NO_SUCH_USER:
499 case ERROR_NO_SUCH_GROUP:
500 case DNS_ERROR_RCODE_NAME_ERROR:
501 case DNS_INFO_NO_RECORDS:
502 miCategory = MI_ERRORCATEGORY_OBJECT_NOT_FOUND;
503 break;
504 case ERROR_CANCELLED:
505 krisbash 1.1 case DNS_ERROR_RCODE_SERVER_FAILURE:
506 miCategory = MI_ERRORCATEGORY_OPERATION_STOPPED;
507 break;
508 case WAIT_TIMEOUT:
509 case ERROR_CANT_WAIT:
510 case ERROR_TIMEOUT:
511 miCategory = MI_ERRORCATEGORY_OPERATION_TIMEOUT;
512 break;
513 case ERROR_ACCESS_DENIED:
514 miCategory = MI_ERRORCATEGORY_ACCESS_DENIED;
515 break;
516 case ERROR_SERVICE_ALREADY_RUNNING:
517 case ERROR_SERVICE_CANNOT_ACCEPT_CTRL:
518 miCategory = MI_ERRORCATEGORY_RESOURCE_BUSY;
519 break;
520 case ERROR_ALREADY_EXISTS:
521 case ERROR_MORE_DATA:
522 case ERROR_OBJECT_NAME_EXISTS:
523 miCategory = MI_ERRORCATEGORY_RESOURCE_EXISTS;
524 break;
525 case ERROR_NOT_ENOUGH_MEMORY:
526 krisbash 1.1 case ERROR_NETNAME_DELETED:
527 case ERROR_INSUFFICIENT_BUFFER:
528 case ERROR_SERVICE_DISABLED:
529 case ERROR_SERVICE_NOT_ACTIVE:
530 case ERROR_SERVICE_NEVER_STARTED:
531 miCategory = MI_ERRORCATEGORY_RESOURCE_UNAVAILABLE;
532 break;
533 case ERROR_CANTREAD:
534 miCategory = MI_ERRORCATEGORY_READ_ERROR;
535 break;
536
537 case ERROR_LOGON_FAILURE:
538 miCategory = MI_ERRORCATEGORY_AUTHENTICATION_ERROR;
539 break;
540 }
541 return miCategory;
542 }
543
544 MI_INLINE MI_Result ResultFromWin32Error(MI_Uint32 error)
545 {
546 MI_Result result = MI_RESULT_FAILED;
547 krisbash 1.1 switch(error)
548 {
549 case ERROR_FILE_NOT_FOUND :
550 result = MI_RESULT_NOT_FOUND;
551 break;
552 case ERROR_PATH_NOT_FOUND :
553 result = MI_RESULT_NOT_FOUND;
554 break;
555 case ERROR_ACCESS_DENIED:
556 result = MI_RESULT_ACCESS_DENIED;
557 break;
558 case ERROR_INVALID_HANDLE :
559 result = MI_RESULT_INVALID_PARAMETER;
560 break;
561 case ERROR_NOT_ENOUGH_MEMORY :
562 result = MI_RESULT_SERVER_LIMITS_EXCEEDED;
563 break;
564 case ERROR_INVALID_DATA :
565 result = MI_RESULT_INVALID_PARAMETER;
566 break;
567 case ERROR_NOT_SUPPORTED :
568 krisbash 1.1 result = MI_RESULT_NOT_SUPPORTED;
569 break;
570 case ERROR_INVALID_PARAMETER :
571 result = MI_RESULT_INVALID_PARAMETER;
572 break;
573 case ERROR_INSUFFICIENT_BUFFER :
574 result = MI_RESULT_INVALID_PARAMETER;
575 break;
576 case ERROR_PROC_NOT_FOUND :
577 result = MI_RESULT_NOT_FOUND;
578 break;
579 case ERROR_BAD_PATHNAME :
580 result = MI_RESULT_INVALID_PARAMETER;
581 break;
582 case ERROR_ALREADY_EXISTS :
583 result = MI_RESULT_ALREADY_EXISTS;
584 break;
585 case ERROR_NO_DATA :
586 result = MI_RESULT_NOT_FOUND;
587 break;
588 case ERROR_NOINTERFACE :
589 krisbash 1.1 result = MI_RESULT_NOT_FOUND;
590 break;
591 case ERROR_OBJECT_NAME_EXISTS :
592 result = MI_RESULT_ALREADY_EXISTS;
593 break;
594 case ERROR_SERVICE_DOES_NOT_EXIST :
595 result = MI_RESULT_NOT_FOUND;
596 break;
597 case ERROR_NOT_FOUND :
598 result = MI_RESULT_NOT_FOUND;
599 break;
600 case ERROR_NO_SUCH_USER :
601 result = MI_RESULT_NOT_FOUND;
602 break;
603 case ERROR_NO_SUCH_GROUP :
604 result = MI_RESULT_NOT_FOUND;
605 break;
606 case DNS_ERROR_RCODE_NAME_ERROR :
607 result = MI_RESULT_NOT_FOUND;
608 break;
609 case DNS_INFO_NO_RECORDS :
610 krisbash 1.1 result = MI_RESULT_NOT_FOUND;
611 break;
612 default :
613 result = MI_RESULT_FAILED;
614 break;
615 }
616 return result;
617 }
618
619 _Success_(return == MI_RESULT_OK)
620 MI_Result OmiErrorFromWin32(
621 _In_opt_ Batch* batch,
622 MI_Uint32 OMI_Code,
623 _In_z_ const MI_Char* Message,
624 _Outptr_opt_result_maybenull_ OMI_Error **omiError)
625 {
626 MI_Result miResult;
627 MI_Char messageId[100];
628 MI_Char *errorMessage = NULL;
629 wchar_t *pMsg;
630
631 krisbash 1.1 if(omiError == NULL)
632 return MI_RESULT_OK;
633
634 *omiError = NULL;
635
636 if (OMI_Code == NOERROR)
637 return MI_RESULT_OK;
638
639 miResult = Instance_New((MI_Instance**)omiError, &OMI_Error_rtti, batch);
640 if (miResult != MI_RESULT_OK)
641 return miResult;
642
643 if( FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_MAX_WIDTH_MASK,
644 NULL, OMI_Code, 0, (wchar_t*)&pMsg, 1, NULL) == 0 )
645 {
646 errorMessage = MI_T("");
647 }
648 else
649 {
650 errorMessage = pMsg;
651 }
652 krisbash 1.1
653 if (Message == NULL)
654 Message = errorMessage;
655
656 Stprintf(messageId, sizeof(messageId)/sizeof(messageId[0]), PAL_T("Windows System Error %d"), OMI_Code);
657
658 if (((miResult = OMI_Error_Set_OMI_Code(*omiError, OMI_Code)) == MI_RESULT_OK) &&
659 ((miResult = OMI_Error_Set_OMI_Type(*omiError, MI_RESULT_TYPE_WIN32)) == MI_RESULT_OK) &&
660 ((miResult = OMI_Error_Set_Message(*omiError, Message)) == MI_RESULT_OK) &&
661 ((miResult = OMI_Error_Set_MessageArguments(*omiError, NULL, 0)) == MI_RESULT_OK) &&
662 ((miResult = OMI_Error_Set_OMI_ErrorMessage(*omiError, errorMessage)) == MI_RESULT_OK) &&
663 ((miResult = OMI_Error_Set_OMI_Category(*omiError, ErrorCategoryFromWin32Error(OMI_Code))) == MI_RESULT_OK) &&
664 ((miResult = OMI_Error_Set_CIMStatusCode(*omiError, ResultFromWin32Error(OMI_Code))) == MI_RESULT_OK) &&
665 ((miResult = OMI_Error_Set_MessageID(*omiError, messageId)) == MI_RESULT_OK) &&
666 ((miResult = OMI_Error_Set_OwningEntity(*omiError, PAL_T("OMI:CIMOM"))) == MI_RESULT_OK) &&
667 ((miResult = OMI_Error_Set_PerceivedSeverity(*omiError, 7)) == MI_RESULT_OK) &&
668 ((miResult = OMI_Error_Set_ProbableCause(*omiError, 0)) == MI_RESULT_OK) &&
669 ((miResult = OMI_Error_Set_ProbableCauseDescription(*omiError, PAL_T("Unknown"))) == MI_RESULT_OK))
670 {
671 }
672
673 krisbash 1.1 if (pMsg)
674 LocalFree(pMsg);
675 return miResult;
676 }
677
678 #endif
679
680 _Success_(return == MI_RESULT_OK)
681 MI_Result OMI_ErrorFromErrorCode(
682 _In_opt_ Batch* batch,
683 MI_Uint32 OMI_Code,
684 _In_z_ const MI_Char *OMI_Type,
685 _In_z_ const MI_Char* OMI_ErrorMessage,
686 _Outptr_opt_result_maybenull_ OMI_Error **omiError)
687 {
688 MI_Result miResult;
689
690 if (omiError == NULL)
691 return MI_RESULT_OK;
692
693 *omiError = NULL;
694 krisbash 1.1
695 if (Tcscmp(OMI_Type, MI_RESULT_TYPE_MI) == 0)
696 {
697 miResult = OmiErrorFromMiCode(batch, OMI_Code, OMI_ErrorMessage, omiError);
698 }
699 else if (Tcscmp(OMI_Type, MI_RESULT_TYPE_ERRNO) == 0)
700 {
701 miResult = OmiErrorFromErrno(batch, OMI_Code, OMI_ErrorMessage, omiError);
702 }
703 #if defined(_MSC_VER)
704 else if (Tcscmp(OMI_Type, MI_RESULT_TYPE_WIN32) == 0)
705 {
706 miResult = OmiErrorFromWin32(batch, OMI_Code, OMI_ErrorMessage, omiError);
707 }
708 #endif
709 else
710 return MI_RESULT_INVALID_PARAMETER;
711
712 if (omiError)
713 {
714 /* Add some common items not handled in the specific code */
715 krisbash 1.1 }
716 if (miResult)
717 {
718 NitsIgnoringError();
719 }
720
721 return MI_RESULT_OK;;
722 }
723
724 MI_ErrorCategory ErrorCategoryFromErrorCode(
725 MI_Uint32 OMI_Code,
726 _In_z_ const MI_Char *OMI_Type)
727 {
728 MI_ErrorCategory errorCategory = MI_ERRORCATEGORY_NOT_SPECIFIED;
729 if (Tcscmp(OMI_Type, MI_RESULT_TYPE_MI) == 0)
730 {
731 errorCategory = ErrorCategoryFromMIResult(OMI_Code);
732 }
733 else if (Tcscmp(OMI_Type, MI_RESULT_TYPE_ERRNO) == 0)
734 {
735 errorCategory = ErrorCategoryFromErrno(OMI_Code);
736 krisbash 1.1 }
737 #if defined(_MSC_VER)
738 else if (Tcscmp(OMI_Type, MI_RESULT_TYPE_WIN32) == 0)
739 {
740 errorCategory = ErrorCategoryFromWin32Error(OMI_Code);
741 }
742 #endif
743
744 return errorCategory;
745 }
746
747 const MI_Char *ErrnoToString(
748 MI_Uint32 OMI_Code,
749 _Out_writes_z_(len) MI_Char *buffer,
750 MI_Uint32 len)
751 {
752 return Errno_ToString(OMI_Code, buffer, len);
753 }
754
|
Return to
omierror.c
CVS log
Up to [OMI] / omi / omi_error