Debian Codegraph @

dat/common/dat_strerror.c

raw
1 /*
2 * Copyright (c) 2002-2005, Network Appliance, Inc. All rights reserved.
3 *
4 * This Software is licensed under one of the following licenses:
5 *
6 * 1) under the terms of the "Common Public License 1.0" a copy of which is
7 * in the file LICENSE.txt in the root directory. The license is also
8 * available from the Open Source Initiative, see
9 * http://www.opensource.org/licenses/cpl.php.
10 *
11 * 2) under the terms of the "The BSD License" a copy of which is in the file
12 * LICENSE2.txt in the root directory. The license is also available from
13 * the Open Source Initiative, see
14 * http://www.opensource.org/licenses/bsd-license.php.
15 *
16 * 3) under the terms of the "GNU General Public License (GPL) Version 2" a
17 * copy of which is in the file LICENSE3.txt in the root directory. The
18 * license is also available from the Open Source Initiative, see
19 * http://www.opensource.org/licenses/gpl-license.php.
20 *
21 * Licensee has the right to choose one of the above licenses.
22 *
23 * Redistributions of source code must retain the above copyright
24 * notice and one of the license notices.
25 *
26 * Redistributions in binary form must reproduce both the above copyright
27 * notice, one of the license notices in the documentation
28 * and/or other materials provided with the distribution.
29 */
30
31 /**********************************************************************
32 *
33 * MODULE: dat_strerror.c
34 *
35 * PURPOSE: Convert DAT_RETURN values to humman readable string
36 *
37 * $Id: dat_strerror.c,v 1.10 2005/03/24 05:58:28 jlentini Exp $
38 **********************************************************************/
39
40 #ifdef __KDAPL__
41 #include <dat2/kdat.h>
42 #else /*__UDAPL__*/
43 #include <dat2/udat.h>
44 #endif /* __UDAPL__ */
45
46 /*********************************************************************
47 * *
48 * Internal Function Declarations *
49 * *
50 *********************************************************************/
51
52 static DAT_RETURN
53 dat_strerror_major(IN DAT_RETURN value, OUT const char **message);
54
55 static DAT_RETURN
56 dat_strerror_minor(IN DAT_RETURN value, OUT const char **message);
57
58 /*********************************************************************
59 * *
60 * Internal Function Definitions *
61 * *
62 *********************************************************************/
63
64 static DAT_RETURN
65 dat_strerror_major(IN DAT_RETURN value, OUT const char **message)
66 {
67 switch (DAT_GET_TYPE(value)) {
68 case DAT_SUCCESS:
69 {
70 *message = "DAT_SUCCESS";
71 return DAT_SUCCESS;
72 }
73 case DAT_ABORT:
74 {
75 *message = "DAT_ABORT";
76 return DAT_SUCCESS;
77 }
78 case DAT_CONN_QUAL_IN_USE:
79 {
80 *message = "DAT_CONN_QUAL_IN_USE";
81 return DAT_SUCCESS;
82 }
83 case DAT_INSUFFICIENT_RESOURCES:
84 {
85 *message = "DAT_INSUFFICIENT_RESOURCES";
86 return DAT_SUCCESS;
87 }
88 case DAT_INTERNAL_ERROR:
89 {
90 *message = "DAT_INTERNAL_ERROR";
91 return DAT_SUCCESS;
92 }
93 case DAT_INVALID_HANDLE:
94 {
95 *message = "DAT_INVALID_HANDLE";
96 return DAT_SUCCESS;
97 }
98 case DAT_INVALID_PARAMETER:
99 {
100 *message = "DAT_INVALID_PARAMETER";
101 return DAT_SUCCESS;
102 }
103 case DAT_INVALID_STATE:
104 {
105 *message = "DAT_INVALID_STATE";
106 return DAT_SUCCESS;
107 }
108 case DAT_LENGTH_ERROR:
109 {
110 *message = "DAT_LENGTH_ERROR";
111 return DAT_SUCCESS;
112 }
113 case DAT_MODEL_NOT_SUPPORTED:
114 {
115 *message = "DAT_MODEL_NOT_SUPPORTED";
116 return DAT_SUCCESS;
117 }
118 case DAT_PROVIDER_NOT_FOUND:
119 {
120 *message = "DAT_PROVIDER_NOT_FOUND";
121 return DAT_SUCCESS;
122 }
123 case DAT_PRIVILEGES_VIOLATION:
124 {
125 *message = "DAT_PRIVILEGES_VIOLATION";
126 return DAT_SUCCESS;
127 }
128 case DAT_PROTECTION_VIOLATION:
129 {
130 *message = "DAT_PROTECTION_VIOLATION";
131 return DAT_SUCCESS;
132 }
133 case DAT_QUEUE_EMPTY:
134 {
135 *message = "DAT_QUEUE_EMPTY";
136 return DAT_SUCCESS;
137 }
138 case DAT_QUEUE_FULL:
139 {
140 *message = "DAT_QUEUE_FULL";
141 return DAT_SUCCESS;
142 }
143 case DAT_TIMEOUT_EXPIRED:
144 {
145 *message = "DAT_TIMEOUT_EXPIRED";
146 return DAT_SUCCESS;
147 }
148 case DAT_PROVIDER_ALREADY_REGISTERED:
149 {
150 *message = "DAT_PROVIDER_ALREADY_REGISTERED";
151 return DAT_SUCCESS;
152 }
153 case DAT_PROVIDER_IN_USE:
154 {
155 *message = "DAT_PROVIDER_IN_USE";
156 return DAT_SUCCESS;
157 }
158 case DAT_INVALID_ADDRESS:
159 {
160 *message = "DAT_INVALID_ADDRESS";
161 return DAT_SUCCESS;
162 }
163 case DAT_INTERRUPTED_CALL:
164 {
165 *message = "DAT_INTERRUPTED_CALL";
166 return DAT_SUCCESS;
167 }
168 case DAT_NOT_IMPLEMENTED:
169 {
170 *message = "DAT_NOT_IMPLEMENTED";
171 return DAT_SUCCESS;
172 }
173 default:
174 {
175 *message = "unknown error";
176 return DAT_INVALID_PARAMETER;
177 }
178 }
179 }
180
181 static DAT_RETURN
182 dat_strerror_minor(IN DAT_RETURN value, OUT const char **message)
183 {
184 switch (DAT_GET_SUBTYPE(value)) {
185
186 case DAT_NO_SUBTYPE: /* NO subtype */
187 {
188 *message = "";
189 return DAT_SUCCESS;
190 }
191 case DAT_SUB_INTERRUPTED:
192 {
193 *message = "DAT_SUB_INTERRUPTED";
194 return DAT_SUCCESS;
195 }
196 case DAT_RESOURCE_MEMORY:
197 {
198 *message = "DAT_RESOURCE_MEMORY";
199 return DAT_SUCCESS;
200 }
201 case DAT_RESOURCE_DEVICE:
202 {
203 *message = "DAT_RESOURCE_DEVICE";
204 return DAT_SUCCESS;
205 }
206 case DAT_RESOURCE_TEP:
207 {
208 *message = "DAT_RESOURCE_TEP";
209 return DAT_SUCCESS;
210 }
211 case DAT_RESOURCE_TEVD:
212 {
213 *message = "DAT_RESOURCE_TEVD";
214 return DAT_SUCCESS;
215 }
216 case DAT_RESOURCE_PROTECTION_DOMAIN:
217 {
218 *message = "DAT_RESOURCE_PROTECTION_DOMAIN";
219 return DAT_SUCCESS;
220 }
221 case DAT_RESOURCE_MEMORY_REGION:
222 {
223 *message = "DAT_RESOURCE_MEMORY_REGION";
224 return DAT_SUCCESS;
225 }
226 case DAT_RESOURCE_ERROR_HANDLER:
227 {
228 *message = "DAT_RESOURCE_ERROR_HANDLER";
229 return DAT_SUCCESS;
230 }
231 case DAT_RESOURCE_CREDITS:
232 {
233 *message = "DAT_RESOURCE_CREDITS";
234 return DAT_SUCCESS;
235 }
236 case DAT_RESOURCE_SRQ:
237 {
238 *message = "DAT_RESOURCE_SRQ";
239 return DAT_SUCCESS;
240 }
241 case DAT_INVALID_HANDLE_IA:
242 {
243 *message = "DAT_INVALID_HANDLE_IA";
244 return DAT_SUCCESS;
245 }
246 case DAT_INVALID_HANDLE_EP:
247 {
248 *message = "DAT_INVALID_HANDLE_EP";
249 return DAT_SUCCESS;
250 }
251 case DAT_INVALID_HANDLE_LMR:
252 {
253 *message = "DAT_INVALID_HANDLE_LMR";
254 return DAT_SUCCESS;
255 }
256 case DAT_INVALID_HANDLE_RMR:
257 {
258 *message = "DAT_INVALID_HANDLE_RMR";
259 return DAT_SUCCESS;
260 }
261 case DAT_INVALID_HANDLE_PZ:
262 {
263 *message = "DAT_INVALID_HANDLE_PZ";
264 return DAT_SUCCESS;
265 }
266 case DAT_INVALID_HANDLE_PSP:
267 {
268 *message = "DAT_INVALID_HANDLE_PSP";
269 return DAT_SUCCESS;
270 }
271 case DAT_INVALID_HANDLE_RSP:
272 {
273 *message = "DAT_INVALID_HANDLE_RSP";
274 return DAT_SUCCESS;
275 }
276 case DAT_INVALID_HANDLE_CR:
277 {
278 *message = "DAT_INVALID_HANDLE_CR";
279 return DAT_SUCCESS;
280 }
281 case DAT_INVALID_HANDLE_CNO:
282 {
283 *message = "DAT_INVALID_HANDLE_CNO";
284 return DAT_SUCCESS;
285 }
286 case DAT_INVALID_HANDLE_EVD_CR:
287 {
288 *message = "DAT_INVALID_HANDLE_EVD_CR";
289 return DAT_SUCCESS;
290 }
291 case DAT_INVALID_HANDLE_EVD_REQUEST:
292 {
293 *message = "DAT_INVALID_HANDLE_EVD_REQUEST";
294 return DAT_SUCCESS;
295 }
296 case DAT_INVALID_HANDLE_EVD_RECV:
297 {
298 *message = "DAT_INVALID_HANDLE_EVD_RECV";
299 return DAT_SUCCESS;
300 }
301 case DAT_INVALID_HANDLE_EVD_CONN:
302 {
303 *message = "DAT_INVALID_HANDLE_EVD_CONN";
304 return DAT_SUCCESS;
305 }
306 case DAT_INVALID_HANDLE_EVD_ASYNC:
307 {
308 *message = "DAT_INVALID_HANDLE_EVD_ASYNC";
309 return DAT_SUCCESS;
310 }
311 case DAT_INVALID_HANDLE_SRQ:
312 {
313 *message = "DAT_INVALID_HANDLE_SRQ";
314 return DAT_SUCCESS;
315 }
316 case DAT_INVALID_HANDLE_CSP:
317 {
318 *message = "DAT_INVALID_HANDLE_CSP";
319 return DAT_SUCCESS;
320 }
321 case DAT_INVALID_HANDLE1:
322 {
323 *message = "DAT_INVALID_HANDLE1";
324 return DAT_SUCCESS;
325 }
326 case DAT_INVALID_HANDLE2:
327 {
328 *message = "DAT_INVALID_HANDLE2";
329 return DAT_SUCCESS;
330 }
331 case DAT_INVALID_HANDLE3:
332 {
333 *message = "DAT_INVALID_HANDLE3";
334 return DAT_SUCCESS;
335 }
336 case DAT_INVALID_HANDLE4:
337 {
338 *message = "DAT_INVALID_HANDLE4";
339 return DAT_SUCCESS;
340 }
341 case DAT_INVALID_HANDLE5:
342 {
343 *message = "DAT_INVALID_HANDLE5";
344 return DAT_SUCCESS;
345 }
346 case DAT_INVALID_HANDLE6:
347 {
348 *message = "DAT_INVALID_HANDLE6";
349 return DAT_SUCCESS;
350 }
351 case DAT_INVALID_HANDLE7:
352 {
353 *message = "DAT_INVALID_HANDLE7";
354 return DAT_SUCCESS;
355 }
356 case DAT_INVALID_HANDLE8:
357 {
358 *message = "DAT_INVALID_HANDLE8";
359 return DAT_SUCCESS;
360 }
361 case DAT_INVALID_HANDLE9:
362 {
363 *message = "DAT_INVALID_HANDLE9";
364 return DAT_SUCCESS;
365 }
366 case DAT_INVALID_HANDLE10:
367 {
368 *message = "DAT_INVALID_HANDLE10";
369 return DAT_SUCCESS;
370 }
371 case DAT_INVALID_ARG1:
372 {
373 *message = "DAT_INVALID_ARG1";
374 return DAT_SUCCESS;
375 }
376 case DAT_INVALID_ARG2:
377 {
378 *message = "DAT_INVALID_ARG2";
379 return DAT_SUCCESS;
380 }
381 case DAT_INVALID_ARG3:
382 {
383 *message = "DAT_INVALID_ARG3";
384 return DAT_SUCCESS;
385 }
386 case DAT_INVALID_ARG4:
387 {
388 *message = "DAT_INVALID_ARG4";
389 return DAT_SUCCESS;
390 }
391 case DAT_INVALID_ARG5:
392 {
393 *message = "DAT_INVALID_ARG5";
394 return DAT_SUCCESS;
395 }
396 case DAT_INVALID_ARG6:
397 {
398 *message = "DAT_INVALID_ARG6";
399 return DAT_SUCCESS;
400 }
401 case DAT_INVALID_ARG7:
402 {
403 *message = "DAT_INVALID_ARG7";
404 return DAT_SUCCESS;
405 }
406 case DAT_INVALID_ARG8:
407 {
408 *message = "DAT_INVALID_ARG8";
409 return DAT_SUCCESS;
410 }
411 case DAT_INVALID_ARG9:
412 {
413 *message = "DAT_INVALID_ARG9";
414 return DAT_SUCCESS;
415 }
416 case DAT_INVALID_ARG10:
417 {
418 *message = "DAT_INVALID_ARG10";
419 return DAT_SUCCESS;
420 }
421 case DAT_INVALID_STATE_EP_UNCONNECTED:
422 {
423 *message = "DAT_INVALID_STATE_EP_UNCONNECTED";
424 return DAT_SUCCESS;
425 }
426 case DAT_INVALID_STATE_EP_ACTCONNPENDING:
427 {
428 *message = "DAT_INVALID_STATE_EP_ACTCONNPENDING";
429 return DAT_SUCCESS;
430 }
431 case DAT_INVALID_STATE_EP_PASSCONNPENDING:
432 {
433 *message = "DAT_INVALID_STATE_EP_PASSCONNPENDING";
434 return DAT_SUCCESS;
435 }
436 case DAT_INVALID_STATE_EP_TENTCONNPENDING:
437 {
438 *message = "DAT_INVALID_STATE_EP_TENTCONNPENDING";
439 return DAT_SUCCESS;
440 }
441 case DAT_INVALID_STATE_EP_CONNECTED:
442 {
443 *message = "DAT_INVALID_STATE_EP_CONNECTED";
444 return DAT_SUCCESS;
445 }
446 case DAT_INVALID_STATE_EP_DISCONNECTED:
447 {
448 *message = "DAT_INVALID_STATE_EP_DISCONNECTED";
449 return DAT_SUCCESS;
450 }
451 case DAT_INVALID_STATE_EP_RESERVED:
452 {
453 *message = "DAT_INVALID_STATE_EP_RESERVED";
454 return DAT_SUCCESS;
455 }
456 case DAT_INVALID_STATE_EP_COMPLPENDING:
457 {
458 *message = "DAT_INVALID_STATE_EP_COMPLPENDING";
459 return DAT_SUCCESS;
460 }
461 case DAT_INVALID_STATE_EP_DISCPENDING:
462 {
463 *message = "DAT_INVALID_STATE_EP_DISCPENDING";
464 return DAT_SUCCESS;
465 }
466 case DAT_INVALID_STATE_EP_PROVIDERCONTROL:
467 {
468 *message = "DAT_INVALID_STATE_EP_PROVIDERCONTROL";
469 return DAT_SUCCESS;
470 }
471 case DAT_INVALID_STATE_EP_NOTREADY:
472 {
473 *message = "DAT_INVALID_STATE_EP_NOTREADY";
474 return DAT_SUCCESS;
475 }
476 case DAT_INVALID_STATE_EP_RECV_WATERMARK:
477 {
478 *message = "DAT_INVALID_STATE_EP_RECV_WATERMARK";
479 return DAT_SUCCESS;
480 }
481 case DAT_INVALID_STATE_EP_PZ:
482 {
483 *message = "DAT_INVALID_STATE_EP_PZ";
484 return DAT_SUCCESS;
485 }
486 case DAT_INVALID_STATE_EP_EVD_REQUEST:
487 {
488 *message = "DAT_INVALID_STATE_EP_EVD_REQUEST";
489 return DAT_SUCCESS;
490 }
491 case DAT_INVALID_STATE_EP_EVD_RECV:
492 {
493 *message = "DAT_INVALID_STATE_EP_EVD_RCV";
494 return DAT_SUCCESS;
495 }
496 case DAT_INVALID_STATE_EP_EVD_CONNECT:
497 {
498 *message = "DAT_INVALID_STATE_EP_EVD_CONNECT";
499 return DAT_SUCCESS;
500 }
501 case DAT_INVALID_STATE_EP_UNCONFIGURED:
502 {
503 *message = "DAT_INVALID_STATE_EP_UNCONFIGURED";
504 return DAT_SUCCESS;
505 }
506 case DAT_INVALID_STATE_EP_UNCONFRESERVED:
507 {
508 *message = "DAT_INVALID_STATE_EP_UNCONFRESERVED";
509 return DAT_SUCCESS;
510 }
511 case DAT_INVALID_STATE_EP_UNCONFPASSIVE:
512 {
513 *message = "DAT_INVALID_STATE_EP_UNCONFPASSIVE";
514 return DAT_SUCCESS;
515 }
516 case DAT_INVALID_STATE_EP_UNCONFTENTATIVE:
517 {
518 *message = "DAT_INVALID_STATE_EP_UNCONFTENTATIVE";
519 return DAT_SUCCESS;
520 }
521 case DAT_INVALID_STATE_CNO_IN_USE:
522 {
523 *message = "DAT_INVALID_STATE_CNO_IN_USE";
524 return DAT_SUCCESS;
525 }
526 case DAT_INVALID_STATE_CNO_DEAD:
527 {
528 *message = "DAT_INVALID_STATE_CNO_DEAD";
529 return DAT_SUCCESS;
530 }
531 case DAT_INVALID_STATE_EVD_OPEN:
532 {
533 *message = "DAT_INVALID_STATE_EVD_OPEN";
534 return DAT_SUCCESS;
535 }
536 case DAT_INVALID_STATE_EVD_ENABLED:
537 {
538 *message = "DAT_INVALID_STATE_EVD_ENABLED";
539 return DAT_SUCCESS;
540 }
541 case DAT_INVALID_STATE_EVD_DISABLED:
542 {
543 *message = "DAT_INVALID_STATE_EVD_DISABLED";
544 return DAT_SUCCESS;
545 }
546 case DAT_INVALID_STATE_EVD_WAITABLE:
547 {
548 *message = "DAT_INVALID_STATE_EVD_WAITABLE";
549 return DAT_SUCCESS;
550 }
551 case DAT_INVALID_STATE_EVD_UNWAITABLE:
552 {
553 *message = "DAT_INVALID_STATE_EVD_UNWAITABLE";
554 return DAT_SUCCESS;
555 }
556 case DAT_INVALID_STATE_EVD_IN_USE:
557 {
558 *message = "DAT_INVALID_STATE_EVD_IN_USE";
559 return DAT_SUCCESS;
560 }
561 case DAT_INVALID_STATE_EVD_CONFIG_NOTIFY:
562 {
563 *message = "DAT_INVALID_STATE_EVD_CONFIG_NOTIFY";
564 return DAT_SUCCESS;
565 }
566 case DAT_INVALID_STATE_EVD_CONFIG_SOLICITED:
567 {
568 *message = "DAT_INVALID_STATE_EVD_CONFIG_SOLICITED";
569 return DAT_SUCCESS;
570 }
571 case DAT_INVALID_STATE_EVD_CONFIG_THRESHOLD:
572 {
573 *message = "DAT_INVALID_STATE_EVD_CONFIG_THRESHOLD";
574 return DAT_SUCCESS;
575 }
576 case DAT_INVALID_STATE_EVD_WAITER:
577 {
578 *message = "DAT_INVALID_STATE_EVD_WAITER";
579 return DAT_SUCCESS;
580 }
581 case DAT_INVALID_STATE_EVD_ASYNC:
582 {
583 *message = "DAT_INVALID_STATE_EVD_ASYNC";
584 return DAT_SUCCESS;
585 }
586 case DAT_INVALID_STATE_IA_IN_USE:
587 {
588 *message = "DAT_INVALID_STATE_IA_IN_USE";
589 return DAT_SUCCESS;
590 }
591 case DAT_INVALID_STATE_LMR_IN_USE:
592 {
593 *message = "DAT_INVALID_STATE_LMR_IN_USE";
594 return DAT_SUCCESS;
595 }
596 case DAT_INVALID_STATE_LMR_FREE:
597 {
598 *message = "DAT_INVALID_STATE_LMR_FREE";
599 return DAT_SUCCESS;
600 }
601 case DAT_INVALID_STATE_PZ_IN_USE:
602 {
603 *message = "DAT_INVALID_STATE_PZ_IN_USE";
604 return DAT_SUCCESS;
605 }
606 case DAT_INVALID_STATE_PZ_FREE:
607 {
608 *message = "DAT_INVALID_STATE_PZ_FREE";
609 return DAT_SUCCESS;
610 }
611 case DAT_PRIVILEGES_READ:
612 {
613 *message = "DAT_PRIVILEGES_READ";
614 return DAT_SUCCESS;
615 }
616 case DAT_PRIVILEGES_WRITE:
617 {
618 *message = "DAT_PRIVILEGES_WRITE";
619 return DAT_SUCCESS;
620 }
621 case DAT_PRIVILEGES_RDMA_READ:
622 {
623 *message = "DAT_PRIVILEGES_RDMA_READ";
624 return DAT_SUCCESS;
625 }
626 case DAT_PRIVILEGES_RDMA_WRITE:
627 {
628 *message = "DAT_PRIVILEGES_RDMA_WRITE";
629 return DAT_SUCCESS;
630 }
631 case DAT_PROTECTION_READ:
632 {
633 *message = "DAT_PROTECTION_READ";
634 return DAT_SUCCESS;
635 }
636 case DAT_PROTECTION_WRITE:
637 {
638 *message = "DAT_PROTECTION_WRITE";
639 return DAT_SUCCESS;
640 }
641 case DAT_PROTECTION_RDMA_READ:
642 {
643 *message = "DAT_PROTECTION_RDMA_READ";
644 return DAT_SUCCESS;
645 }
646 case DAT_PROTECTION_RDMA_WRITE:
647 {
648 *message = "DAT_PROTECTION_RDMA_WRITE";
649 return DAT_SUCCESS;
650 }
651 case DAT_INVALID_ADDRESS_UNSUPPORTED:
652 {
653 *message = "DAT_INVALID_ADDRESS_UNSUPPORTED";
654 return DAT_SUCCESS;
655 }
656 case DAT_INVALID_ADDRESS_UNREACHABLE:
657 {
658 *message = "DAT_INVALID_ADDRESS_UNREACHABLE";
659 return DAT_SUCCESS;
660 }
661 case DAT_INVALID_ADDRESS_MALFORMED:
662 {
663 *message = "DAT_INVALID_ADDRESS_MALFORMED";
664 return DAT_SUCCESS;
665 }
666 case DAT_NAME_NOT_REGISTERED:
667 {
668 *message = "DAT_NAME_NOT_REGISTERED";
669 return DAT_SUCCESS;
670 }
671 case DAT_MAJOR_NOT_FOUND:
672 {
673 *message = "DAT_MAJOR_NOT_FOUND";
674 return DAT_SUCCESS;
675 }
676 case DAT_MINOR_NOT_FOUND:
677 {
678 *message = "DAT_MINOR_NOT_FOUND";
679 return DAT_SUCCESS;
680 }
681 case DAT_THREAD_SAFETY_NOT_FOUND:
682 {
683 *message = "DAT_THREAD_SAFETY_NOT_FOUND";
684 return DAT_SUCCESS;
685 }
686 default:
687 {
688 *message = "unknown minor error";
689 return DAT_INVALID_PARAMETER;
690 }
691 }
692 }
693
694 /*********************************************************************
695 * *
696 * External Function Definitions *
697 * *
698 *********************************************************************/
699
700 DAT_RETURN DAT_API
701 dat_strerror(IN DAT_RETURN value,
702 OUT const char **major_message, OUT const char **minor_message)
703 {
704 /*
705 * The DAT specification contains a note to implementers
706 * suggesting that the consumer's DAT_RETURN value be used
707 * as an index into a table of text strings. However,
708 * the DAT_RETURN values are not consecutive. Therefore this
709 * implementation does not follow the suggested implementation.
710 */
711
712 if (DAT_SUCCESS != dat_strerror_major(value, major_message)) {
713 return DAT_INVALID_PARAMETER;
714 } else if (minor_message != NULL) {
715 if (DAT_SUCCESS != dat_strerror_minor(value, minor_message)) {
716 return DAT_INVALID_PARAMETER;
717 }
718 }
719
720 return DAT_SUCCESS;
721 }