1 /*
2 * Copyright (c) 2000
3 * Traakan, Inc., Los Altos, CA
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice unmodified, this list of conditions, and the following
11 * disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29 /*
30 * Project: NDMJOB
31 * Ident: $Id: $
32 *
33 * Description:
34 *
35 */
36
37
38 #include "ndmos.h" /* rpc/rpc.h */
39 #include "ndmprotocol.h"
40 #include "ndmp_msg_buf.h"
41 #include "ndmp_translate.h"
42
43
44 #ifndef NDMOS_OPTION_NO_NDMP3
45
46
47 /*
48 * Pervasive Types
49 ****************************************************************
50 */
51
52 /*
53 * ndmp_error
54 ****************************************************************
55 */
56
57 struct enum_conversion ndmp_39_error[] = {
58 { NDMP3_UNDEFINED_ERR, NDMP9_UNDEFINED_ERR }, /* default */
59 { NDMP3_NO_ERR, NDMP9_NO_ERR },
60 { NDMP3_NOT_SUPPORTED_ERR, NDMP9_NOT_SUPPORTED_ERR },
61 { NDMP3_DEVICE_BUSY_ERR, NDMP9_DEVICE_BUSY_ERR },
62 { NDMP3_DEVICE_OPENED_ERR, NDMP9_DEVICE_OPENED_ERR },
63 { NDMP3_NOT_AUTHORIZED_ERR, NDMP9_NOT_AUTHORIZED_ERR },
64 { NDMP3_PERMISSION_ERR, NDMP9_PERMISSION_ERR },
65 { NDMP3_DEV_NOT_OPEN_ERR, NDMP9_DEV_NOT_OPEN_ERR },
66 { NDMP3_IO_ERR, NDMP9_IO_ERR },
67 { NDMP3_TIMEOUT_ERR, NDMP9_TIMEOUT_ERR },
68 { NDMP3_ILLEGAL_ARGS_ERR, NDMP9_ILLEGAL_ARGS_ERR },
69 { NDMP3_NO_TAPE_LOADED_ERR, NDMP9_NO_TAPE_LOADED_ERR },
70 { NDMP3_WRITE_PROTECT_ERR, NDMP9_WRITE_PROTECT_ERR },
71 { NDMP3_EOF_ERR, NDMP9_EOF_ERR },
72 { NDMP3_EOM_ERR, NDMP9_EOM_ERR },
73 { NDMP3_FILE_NOT_FOUND_ERR, NDMP9_FILE_NOT_FOUND_ERR },
74 { NDMP3_BAD_FILE_ERR, NDMP9_BAD_FILE_ERR },
75 { NDMP3_NO_DEVICE_ERR, NDMP9_NO_DEVICE_ERR },
76 { NDMP3_NO_BUS_ERR, NDMP9_NO_BUS_ERR },
77 { NDMP3_XDR_DECODE_ERR, NDMP9_XDR_DECODE_ERR },
78 { NDMP3_ILLEGAL_STATE_ERR, NDMP9_ILLEGAL_STATE_ERR },
79 { NDMP3_UNDEFINED_ERR, NDMP9_UNDEFINED_ERR },
80 { NDMP3_XDR_ENCODE_ERR, NDMP9_XDR_ENCODE_ERR },
81 { NDMP3_NO_MEM_ERR, NDMP9_NO_MEM_ERR },
82 { NDMP3_CONNECT_ERR, NDMP9_CONNECT_ERR },
83 END_ENUM_CONVERSION_TABLE
84 };
85
86
87 extern int
ndmp_3to9_error(ndmp3_error * error3,ndmp9_error * error9)88 ndmp_3to9_error (
89 ndmp3_error *error3,
90 ndmp9_error *error9)
91 {
92 *error9 = convert_enum_to_9 (ndmp_39_error, *error3);
93 return 0;
94 }
95
96 extern int
ndmp_9to3_error(ndmp9_error * error9,ndmp3_error * error3)97 ndmp_9to3_error (
98 ndmp9_error *error9,
99 ndmp3_error *error3)
100 {
101 *error3 = convert_enum_from_9 (ndmp_39_error, *error9);
102 return 0;
103 }
104
105
106
107
108 /*
109 * ndmp_pval
110 ****************************************************************
111 */
112
113 int
ndmp_3to9_pval(ndmp3_pval * pval3,ndmp9_pval * pval9)114 ndmp_3to9_pval (
115 ndmp3_pval *pval3,
116 ndmp9_pval *pval9)
117 {
118 CNVT_STRDUP_TO_9(pval3, pval9, name);
119 CNVT_STRDUP_TO_9(pval3, pval9, value);
120
121 return 0;
122 }
123
124 int
ndmp_9to3_pval(ndmp9_pval * pval9,ndmp3_pval * pval3)125 ndmp_9to3_pval (
126 ndmp9_pval *pval9,
127 ndmp3_pval *pval3)
128 {
129 CNVT_STRDUP_FROM_9(pval3, pval9, name);
130 CNVT_STRDUP_FROM_9(pval3, pval9, value);
131
132 return 0;
133 }
134
135 int
ndmp_3to9_pval_vec(ndmp3_pval * pval3,ndmp9_pval * pval9,unsigned n_pval)136 ndmp_3to9_pval_vec (
137 ndmp3_pval *pval3,
138 ndmp9_pval *pval9,
139 unsigned n_pval)
140 {
141 unsigned int i;
142
143 for (i = 0; i < n_pval; i++)
144 ndmp_3to9_pval (&pval3[i], &pval9[i]);
145
146 return 0;
147 }
148
149 int
ndmp_9to3_pval_vec(ndmp9_pval * pval9,ndmp3_pval * pval3,unsigned n_pval)150 ndmp_9to3_pval_vec (
151 ndmp9_pval *pval9,
152 ndmp3_pval *pval3,
153 unsigned n_pval)
154 {
155 unsigned int i;
156
157 for (i = 0; i < n_pval; i++)
158 ndmp_9to3_pval (&pval9[i], &pval3[i]);
159
160 return 0;
161 }
162
163 int
ndmp_3to9_pval_vec_dup(ndmp3_pval * pval3,ndmp9_pval ** pval9_p,unsigned n_pval)164 ndmp_3to9_pval_vec_dup (
165 ndmp3_pval *pval3,
166 ndmp9_pval **pval9_p,
167 unsigned n_pval)
168 {
169 *pval9_p = NDMOS_MACRO_NEWN (ndmp9_pval, n_pval);
170 if (!*pval9_p)
171 return -1;
172
173 return ndmp_3to9_pval_vec (pval3, *pval9_p, n_pval);
174 }
175
176 int
ndmp_9to3_pval_vec_dup(ndmp9_pval * pval9,ndmp3_pval ** pval3_p,unsigned n_pval)177 ndmp_9to3_pval_vec_dup (
178 ndmp9_pval *pval9,
179 ndmp3_pval **pval3_p,
180 unsigned n_pval)
181 {
182 *pval3_p = NDMOS_MACRO_NEWN (ndmp3_pval, n_pval);
183 if (!*pval3_p)
184 return -1;
185
186 return ndmp_9to3_pval_vec (pval9, *pval3_p, n_pval);
187 }
188
189
190 /*
191 * ndmp_addr
192 ****************************************************************
193 */
194
195 struct enum_conversion ndmp_39_addr_type[] = {
196 { NDMP_INVALID_GENERAL, NDMP_INVALID_GENERAL }, /* default */
197 { NDMP3_ADDR_LOCAL, NDMP9_ADDR_LOCAL },
198 { NDMP3_ADDR_TCP, NDMP9_ADDR_TCP },
199 END_ENUM_CONVERSION_TABLE
200 };
201
202
203 extern int
ndmp_3to9_addr(ndmp3_addr * addr3,ndmp9_addr * addr9)204 ndmp_3to9_addr (
205 ndmp3_addr *addr3,
206 ndmp9_addr *addr9)
207 {
208 switch (addr3->addr_type) {
209 case NDMP3_ADDR_LOCAL:
210 addr9->addr_type = NDMP9_ADDR_LOCAL;
211 break;
212
213 case NDMP3_ADDR_TCP:
214 addr9->addr_type = NDMP9_ADDR_TCP;
215 addr9->ndmp9_addr_u.tcp_addr.ip_addr =
216 addr3->ndmp3_addr_u.tcp_addr.ip_addr;
217 addr9->ndmp9_addr_u.tcp_addr.port =
218 addr3->ndmp3_addr_u.tcp_addr.port;
219 break;
220
221 default:
222 NDMOS_MACRO_ZEROFILL (addr9);
223 addr9->addr_type = -1;
224 return -1;
225 }
226
227 return 0;
228 }
229
230 extern int
ndmp_9to3_addr(ndmp9_addr * addr9,ndmp3_addr * addr3)231 ndmp_9to3_addr (
232 ndmp9_addr *addr9,
233 ndmp3_addr *addr3)
234 {
235 switch (addr9->addr_type) {
236 case NDMP9_ADDR_LOCAL:
237 addr3->addr_type = NDMP3_ADDR_LOCAL;
238 break;
239
240 case NDMP9_ADDR_TCP:
241 addr3->addr_type = NDMP3_ADDR_TCP;
242 addr3->ndmp3_addr_u.tcp_addr.ip_addr =
243 addr9->ndmp9_addr_u.tcp_addr.ip_addr;
244 addr3->ndmp3_addr_u.tcp_addr.port =
245 addr9->ndmp9_addr_u.tcp_addr.port;
246 break;
247
248 default:
249 NDMOS_MACRO_ZEROFILL (addr3);
250 addr3->addr_type = -1;
251 return -1;
252 }
253
254 return 0;
255 }
256
257
258
259
260 /*
261 * CONNECT INTERFACES
262 ****************************************************************
263 */
264
265 struct enum_conversion ndmp_39_auth_type[] = {
266 { NDMP_INVALID_GENERAL, NDMP_INVALID_GENERAL }, /* default */
267 { NDMP3_AUTH_NONE, NDMP9_AUTH_NONE },
268 { NDMP3_AUTH_TEXT, NDMP9_AUTH_TEXT },
269 { NDMP3_AUTH_MD5, NDMP9_AUTH_MD5 },
270 END_ENUM_CONVERSION_TABLE
271 };
272
273 int
ndmp_3to9_auth_data(ndmp3_auth_data * auth_data3,ndmp9_auth_data * auth_data9)274 ndmp_3to9_auth_data (
275 ndmp3_auth_data *auth_data3,
276 ndmp9_auth_data *auth_data9)
277 {
278 int n_error = 0;
279 int rc;
280 ndmp3_auth_text *text3;
281 ndmp9_auth_text *text9;
282 ndmp3_auth_md5 *md53;
283 ndmp9_auth_md5 *md59;
284
285 switch (auth_data3->auth_type) {
286 case NDMP3_AUTH_NONE:
287 auth_data9->auth_type = NDMP9_AUTH_NONE;
288 break;
289
290 case NDMP3_AUTH_TEXT:
291 auth_data9->auth_type = NDMP9_AUTH_TEXT;
292 text3 = &auth_data3->ndmp3_auth_data_u.auth_text;
293 text9 = &auth_data9->ndmp9_auth_data_u.auth_text;
294 rc = CNVT_STRDUP_TO_9(text3, text9, auth_id);
295 if (rc) {
296 return rc; /* no mem */
297 }
298 rc = CNVT_STRDUP_TO_9(text3, text9, auth_password);
299 if (rc) {
300 NDMOS_API_FREE (text9->auth_id);
301 text9->auth_id = 0;
302 return rc; /* no mem */
303 }
304 break;
305
306 case NDMP3_AUTH_MD5:
307 auth_data9->auth_type = NDMP9_AUTH_MD5;
308 md53 = &auth_data3->ndmp3_auth_data_u.auth_md5;
309 md59 = &auth_data9->ndmp9_auth_data_u.auth_md5;
310 rc = CNVT_STRDUP_TO_9(md53, md59, auth_id);
311 if (rc) {
312 return rc; /* no mem */
313 }
314 NDMOS_API_BCOPY (md53->auth_digest, md59->auth_digest, 16);
315 break;
316
317 default:
318 auth_data9->auth_type = auth_data3->auth_type;
319 NDMOS_MACRO_ZEROFILL (&auth_data9->ndmp9_auth_data_u);
320 n_error++;
321 break;
322 }
323
324 return n_error;
325 }
326
327 int
ndmp_9to3_auth_data(ndmp9_auth_data * auth_data9,ndmp3_auth_data * auth_data3)328 ndmp_9to3_auth_data (
329 ndmp9_auth_data *auth_data9,
330 ndmp3_auth_data *auth_data3)
331 {
332 int n_error = 0;
333 int rc;
334 ndmp9_auth_text *text9;
335 ndmp3_auth_text *text3;
336 ndmp9_auth_md5 *md59;
337 ndmp3_auth_md5 *md53;
338
339 switch (auth_data9->auth_type) {
340 case NDMP9_AUTH_NONE:
341 auth_data3->auth_type = NDMP3_AUTH_NONE;
342 break;
343
344 case NDMP9_AUTH_TEXT:
345 auth_data3->auth_type = NDMP3_AUTH_TEXT;
346 text9 = &auth_data9->ndmp9_auth_data_u.auth_text;
347 text3 = &auth_data3->ndmp3_auth_data_u.auth_text;
348 rc = CNVT_STRDUP_FROM_9(text3, text9, auth_id);
349 if (rc) {
350 return rc; /* no mem */
351 }
352 rc = CNVT_STRDUP_FROM_9(text3, text9, auth_password);
353 if (rc) {
354 NDMOS_API_FREE (text9->auth_id);
355 text3->auth_id = 0;
356 return rc; /* no mem */
357 }
358 break;
359
360 case NDMP9_AUTH_MD5:
361 auth_data3->auth_type = NDMP3_AUTH_MD5;
362 md59 = &auth_data9->ndmp9_auth_data_u.auth_md5;
363 md53 = &auth_data3->ndmp3_auth_data_u.auth_md5;
364 rc = CNVT_STRDUP_FROM_9(md53, md59, auth_id);
365 if (rc) {
366 return rc; /* no mem */
367 }
368 NDMOS_API_BCOPY (md59->auth_digest, md53->auth_digest, 16);
369 break;
370
371 default:
372 auth_data3->auth_type = auth_data9->auth_type;
373 NDMOS_MACRO_ZEROFILL (&auth_data3->ndmp3_auth_data_u);
374 n_error++;
375 break;
376 }
377
378 return n_error;
379 }
380
381 int
ndmp_3to9_auth_attr(ndmp3_auth_attr * auth_attr3,ndmp9_auth_attr * auth_attr9)382 ndmp_3to9_auth_attr (
383 ndmp3_auth_attr *auth_attr3,
384 ndmp9_auth_attr *auth_attr9)
385 {
386 int n_error = 0;
387
388 switch (auth_attr3->auth_type) {
389 case NDMP3_AUTH_NONE:
390 auth_attr9->auth_type = NDMP9_AUTH_NONE;
391 break;
392
393 case NDMP3_AUTH_TEXT:
394 auth_attr9->auth_type = NDMP9_AUTH_TEXT;
395 break;
396
397 case NDMP3_AUTH_MD5:
398 auth_attr9->auth_type = NDMP9_AUTH_MD5;
399 NDMOS_API_BCOPY (auth_attr3->ndmp3_auth_attr_u.challenge,
400 auth_attr9->ndmp9_auth_attr_u.challenge, 64);
401 break;
402
403 default:
404 auth_attr9->auth_type = auth_attr3->auth_type;
405 NDMOS_MACRO_ZEROFILL (&auth_attr9->ndmp9_auth_attr_u);
406 n_error++;
407 break;
408 }
409
410 return n_error;
411 }
412
413 int
ndmp_9to3_auth_attr(ndmp9_auth_attr * auth_attr9,ndmp3_auth_attr * auth_attr3)414 ndmp_9to3_auth_attr (
415 ndmp9_auth_attr *auth_attr9,
416 ndmp3_auth_attr *auth_attr3)
417 {
418 int n_error = 0;
419
420 switch (auth_attr9->auth_type) {
421 case NDMP9_AUTH_NONE:
422 auth_attr3->auth_type = NDMP3_AUTH_NONE;
423 break;
424
425 case NDMP9_AUTH_TEXT:
426 auth_attr3->auth_type = NDMP3_AUTH_TEXT;
427 break;
428
429 case NDMP9_AUTH_MD5:
430 auth_attr3->auth_type = NDMP3_AUTH_MD5;
431 NDMOS_API_BCOPY (auth_attr9->ndmp9_auth_attr_u.challenge,
432 auth_attr3->ndmp3_auth_attr_u.challenge, 64);
433 break;
434
435 default:
436 auth_attr3->auth_type = auth_attr9->auth_type;
437 NDMOS_MACRO_ZEROFILL (&auth_attr3->ndmp3_auth_attr_u);
438 n_error++;
439 break;
440 }
441
442 return n_error;
443 }
444
445
446 /*
447 * ndmp_connect_open
448 * just error reply
449 */
450
451 int
ndmp_3to9_connect_open_request(ndmp3_connect_open_request * request3,ndmp9_connect_open_request * request9)452 ndmp_3to9_connect_open_request (
453 ndmp3_connect_open_request *request3,
454 ndmp9_connect_open_request *request9)
455 {
456 CNVT_TO_9 (request3, request9, protocol_version);
457 return 0;
458 }
459
460 int
ndmp_9to3_connect_open_request(ndmp9_connect_open_request * request9,ndmp3_connect_open_request * request3)461 ndmp_9to3_connect_open_request (
462 ndmp9_connect_open_request *request9,
463 ndmp3_connect_open_request *request3)
464 {
465 CNVT_FROM_9 (request3, request9, protocol_version);
466 return 0;
467 }
468
469
470 /*
471 * ndmp_connect_client_auth
472 * just error reply
473 */
474
475 int
ndmp_3to9_connect_client_auth_request(ndmp3_connect_client_auth_request * request3,ndmp9_connect_client_auth_request * request9)476 ndmp_3to9_connect_client_auth_request (
477 ndmp3_connect_client_auth_request *request3,
478 ndmp9_connect_client_auth_request *request9)
479 {
480 int rc;
481
482 rc = ndmp_3to9_auth_data (&request3->auth_data, &request9->auth_data);
483
484 return rc;
485 }
486
487 int
ndmp_9to3_connect_client_auth_request(ndmp9_connect_client_auth_request * request9,ndmp3_connect_client_auth_request * request3)488 ndmp_9to3_connect_client_auth_request (
489 ndmp9_connect_client_auth_request *request9,
490 ndmp3_connect_client_auth_request *request3)
491 {
492 int rc;
493
494 rc = ndmp_9to3_auth_data (&request9->auth_data, &request3->auth_data);
495
496 return rc;
497 }
498
499
500 /*
501 * ndmp_connect_close
502 * no arg request, **NO REPLY**
503 */
504
505 /*
506 * ndmp_connect_server_auth
507 */
508
509 /* TBD */
510 int
ndmp_3to9_connect_server_auth_request(ndmp3_connect_server_auth_request * request3,ndmp9_connect_server_auth_request * request9)511 ndmp_3to9_connect_server_auth_request (
512 ndmp3_connect_server_auth_request *request3,
513 ndmp9_connect_server_auth_request *request9)
514 {
515 return -1;
516 }
517
518 int
ndmp_9to3_connect_server_auth_request(ndmp9_connect_server_auth_request * request9,ndmp3_connect_server_auth_request * request3)519 ndmp_9to3_connect_server_auth_request (
520 ndmp9_connect_server_auth_request *request9,
521 ndmp3_connect_server_auth_request *request3)
522 {
523 return -1;
524 }
525
526
527
528
529 /*
530 * CONFIG INTERFACES
531 ****************************************************************
532 */
533
534 int
ndmp_3to9_device_info_vec_dup(ndmp3_device_info * devinf3,ndmp9_device_info ** devinf9_p,int n_devinf)535 ndmp_3to9_device_info_vec_dup (
536 ndmp3_device_info *devinf3,
537 ndmp9_device_info **devinf9_p,
538 int n_devinf)
539 {
540 ndmp9_device_info * devinf9;
541 int i;
542 unsigned int j;
543
544 devinf9 = *devinf9_p = NDMOS_MACRO_NEWN(ndmp9_device_info, n_devinf);
545 if (!devinf9) {
546 return -1; /* no mem */
547 }
548
549 for (i = 0; i < n_devinf; i++) {
550 ndmp3_device_info * di3 = &devinf3[i];
551 ndmp9_device_info * di9 = &devinf9[i];
552
553 NDMOS_MACRO_ZEROFILL (di9);
554
555 CNVT_STRDUP_TO_9 (di3, di9, model);
556
557 di9->caplist.caplist_val =
558 NDMOS_MACRO_NEWN (ndmp9_device_capability,
559 di3->caplist.caplist_len);
560
561 if (!di9->caplist.caplist_val) {
562 return -1;
563 }
564
565 for (j = 0; j < di3->caplist.caplist_len; j++) {
566 ndmp3_device_capability * cap3;
567 ndmp9_device_capability * cap9;
568
569 cap3 = &di3->caplist.caplist_val[j];
570 cap9 = &di9->caplist.caplist_val[j];
571
572 NDMOS_MACRO_ZEROFILL (cap9);
573
574 cap9->v3attr.valid = NDMP9_VALIDITY_VALID;
575 cap9->v3attr.value = cap3->attr;
576
577 CNVT_STRDUP_TO_9 (cap3, cap9, device);
578
579 ndmp_3to9_pval_vec_dup (
580 cap3->capability.capability_val,
581 &cap9->capability.capability_val,
582 cap3->capability.capability_len);
583
584 cap9->capability.capability_len =
585 cap3->capability.capability_len;
586 }
587 di9->caplist.caplist_len = j;
588 }
589
590 return 0;
591 }
592
593 int
ndmp_9to3_device_info_vec_dup(ndmp9_device_info * devinf9,ndmp3_device_info ** devinf3_p,int n_devinf)594 ndmp_9to3_device_info_vec_dup (
595 ndmp9_device_info *devinf9,
596 ndmp3_device_info **devinf3_p,
597 int n_devinf)
598 {
599 ndmp3_device_info * devinf3;
600 int i;
601 unsigned int j;
602
603 devinf3 = *devinf3_p = NDMOS_MACRO_NEWN(ndmp3_device_info, n_devinf);
604 if (!devinf3) {
605 return -1; /* no mem */
606 }
607
608 for (i = 0; i < n_devinf; i++) {
609 ndmp9_device_info * di9 = &devinf9[i];
610 ndmp3_device_info * di3 = &devinf3[i];
611
612 NDMOS_MACRO_ZEROFILL (di3);
613
614 CNVT_STRDUP_FROM_9 (di3, di9, model);
615
616 di3->caplist.caplist_val =
617 NDMOS_MACRO_NEWN (ndmp3_device_capability,
618 di9->caplist.caplist_len);
619
620 if (!di3->caplist.caplist_val) {
621 return -1;
622 }
623
624 for (j = 0; j < di9->caplist.caplist_len; j++) {
625 ndmp9_device_capability * cap9;
626 ndmp3_device_capability * cap3;
627
628 cap9 = &di9->caplist.caplist_val[j];
629 cap3 = &di3->caplist.caplist_val[j];
630
631 NDMOS_MACRO_ZEROFILL (cap3);
632
633 CNVT_STRDUP_FROM_9 (cap3, cap9, device);
634
635 ndmp_9to3_pval_vec_dup (
636 cap9->capability.capability_val,
637 &cap3->capability.capability_val,
638 cap9->capability.capability_len);
639
640 cap3->capability.capability_len =
641 cap9->capability.capability_len;
642 }
643 di3->caplist.caplist_len = j;
644 }
645
646 return 0;
647 }
648
649
650 /*
651 * ndmp_config_get_host_info
652 * no args request
653 */
654
655 int
ndmp_3to9_config_get_host_info_reply(ndmp3_config_get_host_info_reply * reply3,ndmp9_config_get_host_info_reply * reply9)656 ndmp_3to9_config_get_host_info_reply (
657 ndmp3_config_get_host_info_reply *reply3,
658 ndmp9_config_get_host_info_reply *reply9)
659 {
660 int n_error = 0;
661
662 CNVT_E_TO_9 (reply3, reply9, error, ndmp_39_error);
663 CNVT_STRDUP_TO_9x (reply3, reply9, hostname, config_info.hostname);
664 CNVT_STRDUP_TO_9x (reply3, reply9, os_type, config_info.os_type);
665 CNVT_STRDUP_TO_9x (reply3, reply9, os_vers, config_info.os_vers);
666 CNVT_STRDUP_TO_9x (reply3, reply9, hostid, config_info.hostid);
667
668 return n_error;
669 }
670
671 int
ndmp_9to3_config_get_host_info_reply(ndmp9_config_get_host_info_reply * reply9,ndmp3_config_get_host_info_reply * reply3)672 ndmp_9to3_config_get_host_info_reply (
673 ndmp9_config_get_host_info_reply *reply9,
674 ndmp3_config_get_host_info_reply *reply3)
675 {
676 CNVT_E_FROM_9 (reply3, reply9, error, ndmp_39_error);
677 CNVT_STRDUP_FROM_9x (reply3, reply9, hostname, config_info.hostname);
678 CNVT_STRDUP_FROM_9x (reply3, reply9, os_type, config_info.os_type);
679 CNVT_STRDUP_FROM_9x (reply3, reply9, os_vers, config_info.os_vers);
680 CNVT_STRDUP_FROM_9x (reply3, reply9, hostid, config_info.hostid);
681
682 return 0;
683 }
684
685
686
687 /*
688 * ndmp_config_get_connection_type
689 * no args request
690 */
691
692 int
ndmp_3to9_config_get_connection_type_reply(ndmp3_config_get_connection_type_reply * reply3,ndmp9_config_get_connection_type_reply * reply9)693 ndmp_3to9_config_get_connection_type_reply (
694 ndmp3_config_get_connection_type_reply *reply3,
695 ndmp9_config_get_connection_type_reply *reply9)
696 {
697 int n_error = 0;
698 unsigned int i;
699
700 CNVT_E_TO_9 (reply3, reply9, error, ndmp_39_error);
701 for (i = 0; i < reply3->addr_types.addr_types_len; i++) {
702 switch (reply3->addr_types.addr_types_val[i]) {
703 case NDMP3_ADDR_LOCAL:
704 reply9->config_info.conntypes |=
705 NDMP9_CONFIG_CONNTYPE_LOCAL;
706 break;
707
708 case NDMP3_ADDR_TCP:
709 reply9->config_info.conntypes |=
710 NDMP9_CONFIG_CONNTYPE_TCP;
711 break;
712
713 default:
714 n_error++;
715 /* ignore */
716 break;
717 }
718 }
719
720 return n_error;
721 }
722
723 int
ndmp_9to3_config_get_connection_type_reply(ndmp9_config_get_connection_type_reply * reply9,ndmp3_config_get_connection_type_reply * reply3)724 ndmp_9to3_config_get_connection_type_reply (
725 ndmp9_config_get_connection_type_reply *reply9,
726 ndmp3_config_get_connection_type_reply *reply3)
727 {
728 int i = 0;
729
730 CNVT_E_FROM_9 (reply3, reply9, error, ndmp_39_error);
731
732 reply3->addr_types.addr_types_val =
733 NDMOS_MACRO_NEWN(ndmp3_addr_type, 3);
734 if (!reply3->addr_types.addr_types_val) {
735 return -1; /* no mem */
736 }
737
738 i = 0;
739 if (reply9->config_info.conntypes & NDMP9_CONFIG_CONNTYPE_LOCAL) {
740 reply3->addr_types.addr_types_val[i++] = NDMP3_ADDR_LOCAL;
741 }
742 if (reply9->config_info.conntypes & NDMP9_CONFIG_CONNTYPE_TCP) {
743 reply3->addr_types.addr_types_val[i++] = NDMP3_ADDR_TCP;
744 }
745 reply3->addr_types.addr_types_len = i;
746
747 return 0;
748 }
749
750
751 /*
752 * ndmp_config_get_auth_attr
753 */
754
755 int
ndmp_3to9_config_get_auth_attr_request(struct ndmp3_config_get_auth_attr_request * request3,struct ndmp9_config_get_auth_attr_request * request9)756 ndmp_3to9_config_get_auth_attr_request (
757 struct ndmp3_config_get_auth_attr_request *request3,
758 struct ndmp9_config_get_auth_attr_request *request9)
759 {
760 int n_error = 0;
761 int rc;
762
763 rc = CNVT_E_TO_9 (request3, request9, auth_type, ndmp_39_auth_type);
764 if (rc == NDMP_INVALID_GENERAL) {
765 CNVT_TO_9 (request3, request9, auth_type);
766 n_error++;
767 }
768
769 return n_error;
770 }
771
772 int
ndmp_9to3_config_get_auth_attr_request(struct ndmp9_config_get_auth_attr_request * request9,struct ndmp3_config_get_auth_attr_request * request3)773 ndmp_9to3_config_get_auth_attr_request (
774 struct ndmp9_config_get_auth_attr_request *request9,
775 struct ndmp3_config_get_auth_attr_request *request3)
776 {
777 int n_error = 0;
778 int rc;
779
780 rc = CNVT_E_FROM_9 (request3, request9, auth_type, ndmp_39_auth_type);
781 if (rc == NDMP_INVALID_GENERAL) {
782 CNVT_FROM_9 (request3, request9, auth_type);
783 n_error++;
784 }
785
786 return n_error;
787 }
788
789 int
ndmp_3to9_config_get_auth_attr_reply(struct ndmp3_config_get_auth_attr_reply * reply3,struct ndmp9_config_get_auth_attr_reply * reply9)790 ndmp_3to9_config_get_auth_attr_reply (
791 struct ndmp3_config_get_auth_attr_reply *reply3,
792 struct ndmp9_config_get_auth_attr_reply *reply9)
793 {
794 int n_error = 0;
795
796 CNVT_E_TO_9 (reply3, reply9, error, ndmp_39_error);
797
798 n_error += ndmp_3to9_auth_attr (&reply3->server_attr,
799 &reply9->server_attr);
800
801 return n_error;
802 }
803
804 int
ndmp_9to3_config_get_auth_attr_reply(struct ndmp9_config_get_auth_attr_reply * reply9,struct ndmp3_config_get_auth_attr_reply * reply3)805 ndmp_9to3_config_get_auth_attr_reply (
806 struct ndmp9_config_get_auth_attr_reply *reply9,
807 struct ndmp3_config_get_auth_attr_reply *reply3)
808 {
809 int n_error = 0;
810
811 CNVT_E_FROM_9 (reply3, reply9, error, ndmp_39_error);
812
813 n_error += ndmp_9to3_auth_attr (&reply9->server_attr,
814 &reply3->server_attr);
815
816 return n_error;
817 }
818
819
820 /*
821 * ndmp_config_get_butype_info
822 * no args request
823 */
824
825 int
ndmp_3to9_config_get_butype_info_reply(ndmp3_config_get_butype_info_reply * reply3,ndmp9_config_get_butype_info_reply * reply9)826 ndmp_3to9_config_get_butype_info_reply (
827 ndmp3_config_get_butype_info_reply *reply3,
828 ndmp9_config_get_butype_info_reply *reply9)
829 {
830 int n;
831 int i;
832
833 CNVT_E_TO_9 (reply3, reply9, error, ndmp_39_error);
834
835 n = reply3->butype_info.butype_info_len;
836 if (n == 0) {
837 reply9->config_info.butype_info.butype_info_len = 0;
838 reply9->config_info.butype_info.butype_info_val = 0;
839 return 0;
840 }
841
842 reply9->config_info.butype_info.butype_info_val =
843 NDMOS_MACRO_NEWN (ndmp9_butype_info, n);
844
845 for (i = 0; i < n; i++) {
846 ndmp9_butype_info * bu9;
847 ndmp3_butype_info * bu3;
848
849 bu3 = &reply3->butype_info.butype_info_val[i];
850 bu9 = &reply9->config_info.butype_info.butype_info_val[i];
851
852 NDMOS_MACRO_ZEROFILL (bu9);
853
854 CNVT_STRDUP_TO_9 (bu3, bu9, butype_name);
855 ndmp_3to9_pval_vec_dup (bu3->default_env.default_env_val,
856 &bu9->default_env.default_env_val,
857 bu3->default_env.default_env_len);
858
859 bu9->default_env.default_env_len =
860 bu3->default_env.default_env_len;
861
862 bu9->v3attr.valid = NDMP9_VALIDITY_VALID;
863 bu9->v3attr.value = bu3->attrs;
864 }
865
866 reply9->config_info.butype_info.butype_info_len = n;
867
868 return 0;
869 }
870
871 int
ndmp_9to3_config_get_butype_info_reply(ndmp9_config_get_butype_info_reply * reply9,ndmp3_config_get_butype_info_reply * reply3)872 ndmp_9to3_config_get_butype_info_reply (
873 ndmp9_config_get_butype_info_reply *reply9,
874 ndmp3_config_get_butype_info_reply *reply3)
875 {
876 int n;
877 int i;
878
879 CNVT_E_FROM_9 (reply3, reply9, error, ndmp_39_error);
880
881 n = reply9->config_info.butype_info.butype_info_len;
882 if (n == 0) {
883 reply3->butype_info.butype_info_len = 0;
884 reply3->butype_info.butype_info_val = 0;
885 return 0;
886 }
887
888 reply3->butype_info.butype_info_val =
889 NDMOS_MACRO_NEWN (ndmp3_butype_info, n);
890
891 for (i = 0; i < n; i++) {
892 ndmp3_butype_info * bu3;
893 ndmp9_butype_info * bu9;
894
895 bu9 = &reply9->config_info.butype_info.butype_info_val[i];
896 bu3 = &reply3->butype_info.butype_info_val[i];
897
898 NDMOS_MACRO_ZEROFILL (bu3);
899
900 CNVT_STRDUP_FROM_9 (bu3, bu9, butype_name);
901 ndmp_9to3_pval_vec_dup (bu9->default_env.default_env_val,
902 &bu3->default_env.default_env_val,
903 bu9->default_env.default_env_len);
904
905 bu3->default_env.default_env_len =
906 bu9->default_env.default_env_len;
907
908 bu3->attrs = bu9->v3attr.value;
909 }
910
911 reply3->butype_info.butype_info_len = n;
912
913 return 0;
914 }
915
916
917 /*
918 * ndmp_config_get_fs_info
919 * no args request
920 */
921
922 int
ndmp_3to9_config_get_fs_info_reply(ndmp3_config_get_fs_info_reply * reply3,ndmp9_config_get_fs_info_reply * reply9)923 ndmp_3to9_config_get_fs_info_reply (
924 ndmp3_config_get_fs_info_reply *reply3,
925 ndmp9_config_get_fs_info_reply *reply9)
926 {
927 int n;
928 int i;
929
930 CNVT_E_TO_9 (reply3, reply9, error, ndmp_39_error);
931
932 n = reply3->fs_info.fs_info_len;
933 if (n == 0) {
934 reply9->config_info.fs_info.fs_info_len = 0;
935 reply9->config_info.fs_info.fs_info_val = 0;
936 return 0;
937 }
938
939 reply9->config_info.fs_info.fs_info_val =
940 NDMOS_MACRO_NEWN (ndmp9_fs_info, n);
941
942 for (i = 0; i < n; i++) {
943 ndmp3_fs_info * fs3;
944 ndmp9_fs_info * fs9;
945
946 fs3 = &reply3->fs_info.fs_info_val[i];
947 fs9 = &reply9->config_info.fs_info.fs_info_val[i];
948
949 NDMOS_MACRO_ZEROFILL (fs9);
950
951 CNVT_STRDUP_TO_9 (fs3, fs9, fs_type);
952 CNVT_STRDUP_TO_9 (fs3, fs9, fs_logical_device);
953 CNVT_STRDUP_TO_9 (fs3, fs9, fs_physical_device);
954 CNVT_STRDUP_TO_9 (fs3, fs9, fs_status);
955
956 ndmp_3to9_pval_vec_dup (fs3->fs_env.fs_env_val,
957 &fs9->fs_env.fs_env_val,
958 fs3->fs_env.fs_env_len);
959
960 fs9->fs_env.fs_env_len = fs3->fs_env.fs_env_len;
961 }
962
963 reply9->config_info.fs_info.fs_info_len = n;
964
965 return 0;
966 }
967
968 int
ndmp_9to3_config_get_fs_info_reply(ndmp9_config_get_fs_info_reply * reply9,ndmp3_config_get_fs_info_reply * reply3)969 ndmp_9to3_config_get_fs_info_reply (
970 ndmp9_config_get_fs_info_reply *reply9,
971 ndmp3_config_get_fs_info_reply *reply3)
972 {
973 int n;
974 int i;
975
976 CNVT_E_FROM_9 (reply3, reply9, error, ndmp_39_error);
977
978 n = reply9->config_info.fs_info.fs_info_len;
979 if (n == 0) {
980 reply3->fs_info.fs_info_len = 0;
981 reply3->fs_info.fs_info_val = 0;
982 return 0;
983 }
984
985 reply3->fs_info.fs_info_val = NDMOS_MACRO_NEWN (ndmp3_fs_info, n);
986
987 for (i = 0; i < n; i++) {
988 ndmp9_fs_info * fs9;
989 ndmp3_fs_info * fs3;
990
991 fs9 = &reply9->config_info.fs_info.fs_info_val[i];
992 fs3 = &reply3->fs_info.fs_info_val[i];
993
994 NDMOS_MACRO_ZEROFILL (fs3);
995
996 CNVT_STRDUP_FROM_9 (fs3, fs9, fs_type);
997 CNVT_STRDUP_FROM_9 (fs3, fs9, fs_logical_device);
998 CNVT_STRDUP_FROM_9 (fs3, fs9, fs_physical_device);
999 CNVT_STRDUP_FROM_9 (fs3, fs9, fs_status);
1000
1001 ndmp_9to3_pval_vec_dup (fs9->fs_env.fs_env_val,
1002 &fs3->fs_env.fs_env_val,
1003 fs9->fs_env.fs_env_len);
1004
1005 fs3->fs_env.fs_env_len = fs9->fs_env.fs_env_len;
1006 }
1007
1008 reply3->fs_info.fs_info_len = n;
1009
1010 return 0;
1011 }
1012
1013
1014 /*
1015 * ndmp_config_get_tape_info
1016 * no args request
1017 */
1018
1019 int
ndmp_3to9_config_get_tape_info_reply(ndmp3_config_get_tape_info_reply * reply3,ndmp9_config_get_tape_info_reply * reply9)1020 ndmp_3to9_config_get_tape_info_reply (
1021 ndmp3_config_get_tape_info_reply *reply3,
1022 ndmp9_config_get_tape_info_reply *reply9)
1023 {
1024 CNVT_E_TO_9 (reply3, reply9, error, ndmp_39_error);
1025
1026 ndmp_3to9_device_info_vec_dup (
1027 reply3->tape_info.tape_info_val,
1028 &reply9->config_info.tape_info.tape_info_val,
1029 reply3->tape_info.tape_info_len);
1030
1031 reply9->config_info.tape_info.tape_info_len =
1032 reply3->tape_info.tape_info_len;
1033
1034 return 0;
1035 }
1036
1037 int
ndmp_9to3_config_get_tape_info_reply(ndmp9_config_get_tape_info_reply * reply9,ndmp3_config_get_tape_info_reply * reply3)1038 ndmp_9to3_config_get_tape_info_reply (
1039 ndmp9_config_get_tape_info_reply *reply9,
1040 ndmp3_config_get_tape_info_reply *reply3)
1041 {
1042 CNVT_E_FROM_9 (reply3, reply9, error, ndmp_39_error);
1043
1044 ndmp_9to3_device_info_vec_dup (
1045 reply9->config_info.tape_info.tape_info_val,
1046 &reply3->tape_info.tape_info_val,
1047 reply9->config_info.tape_info.tape_info_len);
1048
1049 reply3->tape_info.tape_info_len =
1050 reply9->config_info.tape_info.tape_info_len;
1051
1052 return 0;
1053 }
1054
1055
1056 /*
1057 * ndmp_config_get_scsi_info
1058 * no args request
1059 */
1060
1061 int
ndmp_3to9_config_get_scsi_info_reply(ndmp3_config_get_scsi_info_reply * reply3,ndmp9_config_get_scsi_info_reply * reply9)1062 ndmp_3to9_config_get_scsi_info_reply (
1063 ndmp3_config_get_scsi_info_reply *reply3,
1064 ndmp9_config_get_scsi_info_reply *reply9)
1065 {
1066 CNVT_E_TO_9 (reply3, reply9, error, ndmp_39_error);
1067
1068 ndmp_3to9_device_info_vec_dup (
1069 reply3->scsi_info.scsi_info_val,
1070 &reply9->config_info.scsi_info.scsi_info_val,
1071 reply3->scsi_info.scsi_info_len);
1072
1073 reply9->config_info.scsi_info.scsi_info_len =
1074 reply3->scsi_info.scsi_info_len;
1075
1076 return 0;
1077 }
1078
1079 int
ndmp_9to3_config_get_scsi_info_reply(ndmp9_config_get_scsi_info_reply * reply9,ndmp3_config_get_scsi_info_reply * reply3)1080 ndmp_9to3_config_get_scsi_info_reply (
1081 ndmp9_config_get_scsi_info_reply *reply9,
1082 ndmp3_config_get_scsi_info_reply *reply3)
1083 {
1084 CNVT_E_FROM_9 (reply3, reply9, error, ndmp_39_error);
1085
1086 ndmp_9to3_device_info_vec_dup (
1087 reply9->config_info.scsi_info.scsi_info_val,
1088 &reply3->scsi_info.scsi_info_val,
1089 reply9->config_info.scsi_info.scsi_info_len);
1090
1091 reply3->scsi_info.scsi_info_len =
1092 reply9->config_info.scsi_info.scsi_info_len;
1093
1094 return 0;
1095 }
1096
1097
1098 /*
1099 * ndmp_config_get_server_info
1100 * no args request
1101 */
1102
1103 int
ndmp_3to9_config_get_server_info_reply(ndmp3_config_get_server_info_reply * reply3,ndmp9_config_get_server_info_reply * reply9)1104 ndmp_3to9_config_get_server_info_reply (
1105 ndmp3_config_get_server_info_reply *reply3,
1106 ndmp9_config_get_server_info_reply *reply9)
1107 {
1108 unsigned int i, n_error = 0;
1109
1110 CNVT_E_TO_9 (reply3, reply9, error, ndmp_39_error);
1111 CNVT_STRDUP_TO_9x (reply3, reply9,
1112 vendor_name, config_info.vendor_name);
1113 CNVT_STRDUP_TO_9x (reply3, reply9,
1114 product_name, config_info.product_name);
1115 CNVT_STRDUP_TO_9x (reply3, reply9,
1116 revision_number, config_info.revision_number);
1117
1118 reply9->config_info.authtypes = 0;
1119 for (i = 0; i < reply3->auth_type.auth_type_len; i++) {
1120 switch (reply3->auth_type.auth_type_val[i]) {
1121 case NDMP3_AUTH_NONE:
1122 reply9->config_info.authtypes |=
1123 NDMP9_CONFIG_AUTHTYPE_NONE;
1124 break;
1125
1126 case NDMP3_AUTH_TEXT:
1127 reply9->config_info.authtypes |=
1128 NDMP9_CONFIG_AUTHTYPE_TEXT;
1129 break;
1130
1131 case NDMP3_AUTH_MD5:
1132 reply9->config_info.authtypes |=
1133 NDMP9_CONFIG_AUTHTYPE_MD5;
1134 break;
1135
1136 default:
1137 n_error++;
1138 /* ignore */
1139 break;
1140 }
1141 }
1142
1143 return n_error;
1144 }
1145
1146 int
ndmp_9to3_config_get_server_info_reply(ndmp9_config_get_server_info_reply * reply9,ndmp3_config_get_server_info_reply * reply3)1147 ndmp_9to3_config_get_server_info_reply (
1148 ndmp9_config_get_server_info_reply *reply9,
1149 ndmp3_config_get_server_info_reply *reply3)
1150 {
1151 int i = 0;
1152
1153 CNVT_E_FROM_9 (reply3, reply9, error, ndmp_39_error);
1154 CNVT_STRDUP_FROM_9x (reply3, reply9,
1155 vendor_name, config_info.vendor_name);
1156 CNVT_STRDUP_FROM_9x (reply3, reply9,
1157 product_name, config_info.product_name);
1158 CNVT_STRDUP_FROM_9x (reply3, reply9,
1159 revision_number, config_info.revision_number);
1160
1161 reply3->auth_type.auth_type_val = NDMOS_MACRO_NEWN(ndmp3_auth_type, 3);
1162 if (!reply3->auth_type.auth_type_val) {
1163 return -1;
1164 }
1165
1166 i = 0;
1167 if (reply9->config_info.authtypes & NDMP9_CONFIG_AUTHTYPE_NONE) {
1168 reply3->auth_type.auth_type_val[i++] = NDMP3_AUTH_NONE;
1169 }
1170 if (reply9->config_info.authtypes & NDMP9_CONFIG_AUTHTYPE_TEXT) {
1171 reply3->auth_type.auth_type_val[i++] = NDMP3_AUTH_TEXT;
1172 }
1173 if (reply9->config_info.authtypes & NDMP9_CONFIG_AUTHTYPE_MD5) {
1174 reply3->auth_type.auth_type_val[i++] = NDMP3_AUTH_MD5;
1175 }
1176 reply3->auth_type.auth_type_len = i;
1177
1178 return 0;
1179 }
1180
1181
1182
1183
1184 /*
1185 * SCSI INTERFACES
1186 ****************************************************************
1187 */
1188
1189 /*
1190 * ndmp_scsi_open
1191 * just error reply
1192 */
1193 int
ndmp_3to9_scsi_open_request(ndmp3_scsi_open_request * request3,ndmp9_scsi_open_request * request9)1194 ndmp_3to9_scsi_open_request (
1195 ndmp3_scsi_open_request *request3,
1196 ndmp9_scsi_open_request *request9)
1197 {
1198 request9->device = NDMOS_API_STRDUP (request3->device);
1199 if (!request9->device) {
1200 return -1; /* no memory */
1201 }
1202 return 0;
1203 }
1204
1205 int
ndmp_9to3_scsi_open_request(ndmp9_scsi_open_request * request9,ndmp3_scsi_open_request * request3)1206 ndmp_9to3_scsi_open_request (
1207 ndmp9_scsi_open_request *request9,
1208 ndmp3_scsi_open_request *request3)
1209 {
1210 request3->device = NDMOS_API_STRDUP (request9->device);
1211 if (!request3->device) {
1212 return -1; /* no memory */
1213 }
1214 return 0;
1215 }
1216
1217 /*
1218 * ndmp_scsi_close
1219 * no args request, just error reply
1220 */
1221
1222 /*
1223 * ndmp_scsi_get_state
1224 * no args request
1225 */
1226
1227 int
ndmp_3to9_scsi_get_state_reply(ndmp3_scsi_get_state_reply * reply3,ndmp9_scsi_get_state_reply * reply9)1228 ndmp_3to9_scsi_get_state_reply (
1229 ndmp3_scsi_get_state_reply *reply3,
1230 ndmp9_scsi_get_state_reply *reply9)
1231 {
1232 CNVT_E_TO_9 (reply3, reply9, error, ndmp_39_error);
1233 CNVT_TO_9 (reply3, reply9, target_controller);
1234 CNVT_TO_9 (reply3, reply9, target_id);
1235 CNVT_TO_9 (reply3, reply9, target_lun);
1236
1237 return 0;
1238 }
1239
1240 int
ndmp_9to3_scsi_get_state_reply(ndmp9_scsi_get_state_reply * reply9,ndmp3_scsi_get_state_reply * reply3)1241 ndmp_9to3_scsi_get_state_reply (
1242 ndmp9_scsi_get_state_reply *reply9,
1243 ndmp3_scsi_get_state_reply *reply3)
1244 {
1245 CNVT_E_FROM_9 (reply3, reply9, error, ndmp_39_error);
1246 CNVT_FROM_9 (reply3, reply9, target_controller);
1247 CNVT_FROM_9 (reply3, reply9, target_id);
1248 CNVT_FROM_9 (reply3, reply9, target_lun);
1249
1250 return 0;
1251 }
1252
1253 /*
1254 * ndmp_scsi_set_target -- deprecated
1255 * just error reply
1256 */
1257
1258 int
ndmp_3to9_scsi_set_target_request(ndmp3_scsi_set_target_request * request3,ndmp9_scsi_set_target_request * request9)1259 ndmp_3to9_scsi_set_target_request (
1260 ndmp3_scsi_set_target_request *request3,
1261 ndmp9_scsi_set_target_request *request9)
1262 {
1263 request9->device = NDMOS_API_STRDUP (request3->device);
1264 if (!request9->device) {
1265 return -1; /* no memory */
1266 }
1267
1268 CNVT_TO_9 (request3, request9, target_controller);
1269 CNVT_TO_9 (request3, request9, target_id);
1270 CNVT_TO_9 (request3, request9, target_lun);
1271
1272 return 0;
1273 }
1274
1275 int
ndmp_9to3_scsi_set_target_request(ndmp9_scsi_set_target_request * request9,ndmp3_scsi_set_target_request * request3)1276 ndmp_9to3_scsi_set_target_request (
1277 ndmp9_scsi_set_target_request *request9,
1278 ndmp3_scsi_set_target_request *request3)
1279 {
1280 request3->device = NDMOS_API_STRDUP (request9->device);
1281 if (!request3->device) {
1282 return -1; /* no memory */
1283 }
1284
1285 CNVT_FROM_9 (request3, request9, target_controller);
1286 CNVT_FROM_9 (request3, request9, target_id);
1287 CNVT_FROM_9 (request3, request9, target_lun);
1288
1289 return 0;
1290 }
1291
1292 /*
1293 * ndmp_scsi_reset_device
1294 * no args request, just error reply
1295 */
1296
1297 /*
1298 * ndmp_scsi_reset_bus -- deprecated
1299 * no args request, just error reply
1300 */
1301
1302
1303 /*
1304 * ndmp_tape_execute_cdb
1305 * ndmp_scsi_execute_cdb
1306 */
1307
1308 int
ndmp_3to9_execute_cdb_request(ndmp3_execute_cdb_request * request3,ndmp9_execute_cdb_request * request9)1309 ndmp_3to9_execute_cdb_request (
1310 ndmp3_execute_cdb_request *request3,
1311 ndmp9_execute_cdb_request *request9)
1312 {
1313 int n_error = 0;
1314 uint32_t len;
1315 char * p;
1316
1317 switch (request3->flags) {
1318 case 0:
1319 request9->data_dir = NDMP9_SCSI_DATA_DIR_NONE;
1320 break;
1321
1322 case NDMP3_SCSI_DATA_IN:
1323 request9->data_dir = NDMP9_SCSI_DATA_DIR_IN;
1324 break;
1325
1326 case NDMP3_SCSI_DATA_OUT:
1327 request9->data_dir = NDMP9_SCSI_DATA_DIR_IN;
1328 break;
1329
1330 default:
1331 /* deemed insolvable */
1332 n_error++;
1333 return -1;
1334 }
1335
1336 CNVT_TO_9 (request3, request9, timeout);
1337 CNVT_TO_9 (request3, request9, datain_len);
1338
1339 len = request3->dataout.dataout_len;
1340 if (len > 0) {
1341 p = NDMOS_API_MALLOC (len);
1342 if (!p) {
1343 return -1;
1344 }
1345 NDMOS_API_BCOPY (request3->dataout.dataout_val, p, len);
1346 } else {
1347 len = 0;
1348 p = 0;
1349 }
1350 request9->dataout.dataout_len = len;
1351 request9->dataout.dataout_val = p;
1352
1353 len = request3->cdb.cdb_len;
1354 if (len > 0) {
1355 p = NDMOS_API_MALLOC (len);
1356 if (!p) {
1357 if (request9->dataout.dataout_val) {
1358 NDMOS_API_FREE (request9->dataout.dataout_val);
1359 request9->dataout.dataout_len = 0;
1360 request9->dataout.dataout_val = 0;
1361 }
1362 return -1;
1363 }
1364 NDMOS_API_BCOPY (request3->cdb.cdb_val, p, len);
1365 } else {
1366 len = 0;
1367 p = 0;
1368 }
1369 request9->cdb.cdb_len = len;
1370 request9->cdb.cdb_val = p;
1371
1372 return 0;
1373 }
1374
1375 int
ndmp_9to3_execute_cdb_request(ndmp9_execute_cdb_request * request9,ndmp3_execute_cdb_request * request3)1376 ndmp_9to3_execute_cdb_request (
1377 ndmp9_execute_cdb_request *request9,
1378 ndmp3_execute_cdb_request *request3)
1379 {
1380 int n_error = 0;
1381 uint32_t len;
1382 char * p;
1383
1384 switch (request9->data_dir) {
1385 case NDMP9_SCSI_DATA_DIR_NONE:
1386 request3->flags = 0;
1387 break;
1388
1389 case NDMP9_SCSI_DATA_DIR_IN:
1390 request3->flags = NDMP3_SCSI_DATA_IN;
1391 break;
1392
1393 case NDMP9_SCSI_DATA_DIR_OUT:
1394 request3->flags = NDMP3_SCSI_DATA_OUT;
1395 break;
1396
1397 default:
1398 /* deemed insolvable */
1399 n_error++;
1400 return -1;
1401 }
1402
1403 CNVT_FROM_9 (request3, request9, timeout);
1404 CNVT_FROM_9 (request3, request9, datain_len);
1405
1406 len = request9->dataout.dataout_len;
1407 if (len > 0) {
1408 p = NDMOS_API_MALLOC (len);
1409 if (!p) {
1410 return -1;
1411 }
1412 NDMOS_API_BCOPY (request9->dataout.dataout_val, p, len);
1413 } else {
1414 len = 0;
1415 p = 0;
1416 }
1417 request3->dataout.dataout_len = len;
1418 request3->dataout.dataout_val = p;
1419
1420 len = request9->cdb.cdb_len;
1421 if (len > 0) {
1422 p = NDMOS_API_MALLOC (len);
1423 if (!p) {
1424 if (request3->dataout.dataout_val) {
1425 NDMOS_API_FREE (request3->dataout.dataout_val);
1426 request3->dataout.dataout_len = 0;
1427 request3->dataout.dataout_val = 0;
1428 }
1429 return -1;
1430 }
1431 NDMOS_API_BCOPY (request9->cdb.cdb_val, p, len);
1432 } else {
1433 len = 0;
1434 p = 0;
1435 }
1436 request3->cdb.cdb_len = len;
1437 request3->cdb.cdb_val = p;
1438
1439 return 0;
1440 }
1441
1442 int
ndmp_3to9_execute_cdb_reply(ndmp3_execute_cdb_reply * reply3,ndmp9_execute_cdb_reply * reply9)1443 ndmp_3to9_execute_cdb_reply (
1444 ndmp3_execute_cdb_reply *reply3,
1445 ndmp9_execute_cdb_reply *reply9)
1446 {
1447 uint32_t len;
1448 char * p;
1449
1450 CNVT_E_TO_9 (reply3, reply9, error, ndmp_39_error);
1451 CNVT_TO_9 (reply3, reply9, status);
1452 CNVT_TO_9 (reply3, reply9, dataout_len);
1453
1454 len = reply3->datain.datain_len;
1455 if (len > 0) {
1456 p = NDMOS_API_MALLOC (len);
1457 if (!p) {
1458 return -1;
1459 }
1460 NDMOS_API_BCOPY (reply3->datain.datain_val, p, len);
1461 } else {
1462 len = 0;
1463 p = 0;
1464 }
1465 reply9->datain.datain_len = len;
1466 reply9->datain.datain_val = p;
1467
1468 len = reply3->ext_sense.ext_sense_len;
1469 if (len > 0) {
1470 p = NDMOS_API_MALLOC (len);
1471 if (!p) {
1472 if (reply9->datain.datain_val) {
1473 NDMOS_API_FREE (reply9->datain.datain_val);
1474 reply9->datain.datain_len = 0;
1475 reply9->datain.datain_val = 0;
1476 }
1477 return -1;
1478 }
1479 NDMOS_API_BCOPY (reply3->ext_sense.ext_sense_val, p, len);
1480 } else {
1481 len = 0;
1482 p = 0;
1483 }
1484 reply9->ext_sense.ext_sense_len = len;
1485 reply9->ext_sense.ext_sense_val = p;
1486
1487 return 0;
1488 }
1489
1490 int
ndmp_9to3_execute_cdb_reply(ndmp9_execute_cdb_reply * reply9,ndmp3_execute_cdb_reply * reply3)1491 ndmp_9to3_execute_cdb_reply (
1492 ndmp9_execute_cdb_reply *reply9,
1493 ndmp3_execute_cdb_reply *reply3)
1494 {
1495 uint32_t len;
1496 char * p;
1497
1498 CNVT_E_FROM_9 (reply3, reply9, error, ndmp_39_error);
1499 CNVT_FROM_9 (reply3, reply9, status);
1500 CNVT_FROM_9 (reply3, reply9, dataout_len);
1501
1502 len = reply9->datain.datain_len;
1503 if (len > 0) {
1504 p = NDMOS_API_MALLOC (len);
1505 if (!p) {
1506 return -1;
1507 }
1508 NDMOS_API_BCOPY (reply9->datain.datain_val, p, len);
1509 } else {
1510 len = 0;
1511 p = 0;
1512 }
1513 reply3->datain.datain_len = len;
1514 reply3->datain.datain_val = p;
1515
1516 len = reply9->ext_sense.ext_sense_len;
1517 if (len > 0) {
1518 p = NDMOS_API_MALLOC (len);
1519 if (!p) {
1520 if (reply3->datain.datain_val) {
1521 NDMOS_API_FREE (reply9->datain.datain_val);
1522 reply3->datain.datain_len = 0;
1523 reply3->datain.datain_val = 0;
1524 }
1525 return -1;
1526 }
1527 NDMOS_API_BCOPY (reply9->ext_sense.ext_sense_val, p, len);
1528 } else {
1529 len = 0;
1530 p = 0;
1531 }
1532 reply3->ext_sense.ext_sense_len = len;
1533 reply3->ext_sense.ext_sense_val = p;
1534
1535 return 0;
1536 }
1537
1538
1539
1540
1541 /*
1542 * TAPE INTERFACES
1543 ****************************************************************
1544 */
1545
1546
1547 /*
1548 * ndmp_tape_open_request
1549 * just error reply
1550 */
1551
1552 struct enum_conversion ndmp_39_tape_open_mode[] = {
1553 { NDMP_INVALID_GENERAL, NDMP_INVALID_GENERAL, }, /* default */
1554 { NDMP3_TAPE_READ_MODE, NDMP9_TAPE_READ_MODE },
1555 { NDMP3_TAPE_RDWR_MODE, NDMP9_TAPE_RDWR_MODE },
1556 END_ENUM_CONVERSION_TABLE
1557 };
1558
1559
1560
1561 int
ndmp_3to9_tape_open_request(ndmp3_tape_open_request * request3,ndmp9_tape_open_request * request9)1562 ndmp_3to9_tape_open_request (
1563 ndmp3_tape_open_request *request3,
1564 ndmp9_tape_open_request *request9)
1565 {
1566 int n_error = 0;
1567 int rc;
1568
1569 /*
1570 * Mode codes are compatible between versions.
1571 * We let untranslated values through to
1572 * facilitate testing illegal values.
1573 */
1574 rc = convert_enum_to_9 (ndmp_39_tape_open_mode, request3->mode);
1575 if (rc == NDMP_INVALID_GENERAL) {
1576 n_error++;
1577 request9->mode = request3->mode;
1578 } else {
1579 request9->mode = rc;
1580 }
1581
1582 request9->device = NDMOS_API_STRDUP (request3->device);
1583 if (!request9->device) {
1584 return -1; /* no memory */
1585 }
1586
1587 return n_error;
1588 }
1589
1590 int
ndmp_9to3_tape_open_request(ndmp9_tape_open_request * request9,ndmp3_tape_open_request * request3)1591 ndmp_9to3_tape_open_request (
1592 ndmp9_tape_open_request *request9,
1593 ndmp3_tape_open_request *request3)
1594 {
1595 int n_error = 0;
1596 int rc;
1597
1598 rc = convert_enum_from_9 (ndmp_39_tape_open_mode, request9->mode);
1599 if (rc == NDMP_INVALID_GENERAL) {
1600 n_error++;
1601 request3->mode = request9->mode;
1602 } else {
1603 request3->mode = rc;
1604 }
1605
1606 request3->device = NDMOS_API_STRDUP (request9->device);
1607 if (!request3->device) {
1608 return -1; /* no memory */
1609 }
1610
1611 return n_error;
1612 }
1613
1614
1615
1616
1617
1618 /*
1619 * ndmp_tape_get_state_reply
1620 * no arg request
1621 */
1622
1623 extern int
ndmp_3to9_tape_get_state_reply(ndmp3_tape_get_state_reply * reply3,ndmp9_tape_get_state_reply * reply9)1624 ndmp_3to9_tape_get_state_reply (
1625 ndmp3_tape_get_state_reply *reply3,
1626 ndmp9_tape_get_state_reply *reply9)
1627 {
1628 CNVT_E_TO_9 (reply3, reply9, error, ndmp_39_error);
1629 CNVT_TO_9 (reply3, reply9, flags);
1630 CNVT_VUL_TO_9 (reply3, reply9, file_num);
1631 CNVT_VUL_TO_9 (reply3, reply9, soft_errors);
1632 CNVT_VUL_TO_9 (reply3, reply9, block_size);
1633 CNVT_VUL_TO_9 (reply3, reply9, blockno);
1634 CNVT_VUQ_TO_9 (reply3, reply9, total_space);
1635 CNVT_VUQ_TO_9 (reply3, reply9, space_remain);
1636 #if 0
1637 CNVT_VUL_TO_9 (reply3, reply9, partition);
1638 #endif
1639
1640 if (reply3->invalid & NDMP3_TAPE_STATE_FILE_NUM_INVALID)
1641 CNVT_IUL_TO_9 (reply9, file_num);
1642
1643 if (reply3->invalid & NDMP3_TAPE_STATE_SOFT_ERRORS_INVALID)
1644 CNVT_IUL_TO_9 (reply9, soft_errors);
1645
1646 if (reply3->invalid & NDMP3_TAPE_STATE_BLOCK_SIZE_INVALID)
1647 CNVT_IUL_TO_9 (reply9, block_size);
1648
1649 if (reply3->invalid & NDMP3_TAPE_STATE_BLOCKNO_INVALID)
1650 CNVT_IUL_TO_9 (reply9, blockno);
1651
1652 if (reply3->invalid & NDMP3_TAPE_STATE_TOTAL_SPACE_INVALID)
1653 CNVT_IUQ_TO_9 (reply9, total_space);
1654
1655 if (reply3->invalid & NDMP3_TAPE_STATE_SPACE_REMAIN_INVALID)
1656 CNVT_IUQ_TO_9 (reply9, space_remain);
1657
1658 #if 0
1659 if (reply3->invalid & NDMP3_TAPE_STATE_PARTITION_INVALID)
1660 CNVT_IUL_TO_9 (reply9, partition);
1661 #endif
1662
1663 return 0;
1664 }
1665
1666 extern int
ndmp_9to3_tape_get_state_reply(ndmp9_tape_get_state_reply * reply9,ndmp3_tape_get_state_reply * reply3)1667 ndmp_9to3_tape_get_state_reply (
1668 ndmp9_tape_get_state_reply *reply9,
1669 ndmp3_tape_get_state_reply *reply3)
1670 {
1671 CNVT_E_FROM_9 (reply3, reply9, error, ndmp_39_error);
1672 CNVT_FROM_9 (reply3, reply9, flags);
1673 CNVT_VUL_FROM_9 (reply3, reply9, file_num);
1674 CNVT_VUL_FROM_9 (reply3, reply9, soft_errors);
1675 CNVT_VUL_FROM_9 (reply3, reply9, block_size);
1676 CNVT_VUL_FROM_9 (reply3, reply9, blockno);
1677 CNVT_VUQ_FROM_9 (reply3, reply9, total_space);
1678 CNVT_VUQ_FROM_9 (reply3, reply9, space_remain);
1679 #if 0
1680 CNVT_VUL_FROM_9 (reply3, reply9, partition);
1681 #endif
1682
1683 reply3->invalid = 0;
1684
1685 if (!reply9->file_num.valid)
1686 reply3->invalid |= NDMP3_TAPE_STATE_FILE_NUM_INVALID;
1687
1688 if (!reply9->soft_errors.valid)
1689 reply3->invalid |= NDMP3_TAPE_STATE_SOFT_ERRORS_INVALID;
1690
1691 if (!reply9->block_size.valid)
1692 reply3->invalid |= NDMP3_TAPE_STATE_BLOCK_SIZE_INVALID;
1693
1694 if (!reply9->blockno.valid)
1695 reply3->invalid |= NDMP3_TAPE_STATE_BLOCKNO_INVALID;
1696
1697 if (!reply9->total_space.valid)
1698 reply3->invalid |= NDMP3_TAPE_STATE_TOTAL_SPACE_INVALID;
1699
1700 if (!reply9->space_remain.valid)
1701 reply3->invalid |= NDMP3_TAPE_STATE_SPACE_REMAIN_INVALID;
1702
1703 #if 0
1704 if (!reply9->partition.valid)
1705 reply3->invalid |= NDMP3_TAPE_STATE_PARTITION_INVALID;
1706 #else
1707 reply3->invalid |= NDMP3_TAPE_STATE_PARTITION_INVALID;
1708 #endif
1709
1710 return 0;
1711 }
1712
1713
1714 /*
1715 * ndmp_tape_mtio_request
1716 */
1717
1718 struct enum_conversion ndmp_39_tape_mtio_op[] = {
1719 { NDMP_INVALID_GENERAL, NDMP_INVALID_GENERAL, }, /* default */
1720 { NDMP3_MTIO_FSF, NDMP9_MTIO_FSF },
1721 { NDMP3_MTIO_BSF, NDMP9_MTIO_BSF },
1722 { NDMP3_MTIO_FSR, NDMP9_MTIO_FSR },
1723 { NDMP3_MTIO_BSR, NDMP9_MTIO_BSR },
1724 { NDMP3_MTIO_REW, NDMP9_MTIO_REW },
1725 { NDMP3_MTIO_EOF, NDMP9_MTIO_EOF },
1726 { NDMP3_MTIO_OFF, NDMP9_MTIO_OFF },
1727 END_ENUM_CONVERSION_TABLE
1728 };
1729
1730
1731 int
ndmp_3to9_tape_mtio_request(ndmp3_tape_mtio_request * request3,ndmp9_tape_mtio_request * request9)1732 ndmp_3to9_tape_mtio_request (
1733 ndmp3_tape_mtio_request *request3,
1734 ndmp9_tape_mtio_request *request9)
1735 {
1736 int n_error = 0;
1737 int rc;
1738
1739 rc = CNVT_E_TO_9 (request3, request9, tape_op, ndmp_39_tape_mtio_op);
1740 if (rc == NDMP_INVALID_GENERAL) {
1741 n_error++;
1742 CNVT_TO_9(request3, request9, tape_op);
1743 }
1744
1745 CNVT_TO_9(request3, request9, count);
1746
1747 return n_error;
1748 }
1749
1750 int
ndmp_9to3_tape_mtio_request(ndmp9_tape_mtio_request * request9,ndmp3_tape_mtio_request * request3)1751 ndmp_9to3_tape_mtio_request (
1752 ndmp9_tape_mtio_request *request9,
1753 ndmp3_tape_mtio_request *request3)
1754 {
1755 int n_error = 0;
1756 int rc;
1757
1758 rc = CNVT_E_FROM_9 (request3, request9, tape_op, ndmp_39_tape_mtio_op);
1759 if (rc == NDMP_INVALID_GENERAL) {
1760 n_error++;
1761 CNVT_FROM_9(request3, request9, tape_op);
1762 }
1763
1764 CNVT_FROM_9(request3, request9, count);
1765
1766 return n_error;
1767 }
1768
1769 int
ndmp_3to9_tape_mtio_reply(ndmp3_tape_mtio_reply * reply3,ndmp9_tape_mtio_reply * reply9)1770 ndmp_3to9_tape_mtio_reply (
1771 ndmp3_tape_mtio_reply *reply3,
1772 ndmp9_tape_mtio_reply *reply9)
1773 {
1774 CNVT_E_TO_9 (reply3, reply9, error, ndmp_39_error);
1775 CNVT_TO_9 (reply3, reply9, resid_count);
1776 return 0;
1777 }
1778
1779 int
ndmp_9to3_tape_mtio_reply(ndmp9_tape_mtio_reply * reply9,ndmp3_tape_mtio_reply * reply3)1780 ndmp_9to3_tape_mtio_reply (
1781 ndmp9_tape_mtio_reply *reply9,
1782 ndmp3_tape_mtio_reply *reply3)
1783 {
1784 CNVT_E_FROM_9 (reply3, reply9, error, ndmp_39_error);
1785 CNVT_FROM_9 (reply3, reply9, resid_count);
1786 return 0;
1787 }
1788
1789
1790 /*
1791 * ndmp_tape_write
1792 */
1793
1794 int
ndmp_3to9_tape_write_request(ndmp3_tape_write_request * request3,ndmp9_tape_write_request * request9)1795 ndmp_3to9_tape_write_request (
1796 ndmp3_tape_write_request *request3,
1797 ndmp9_tape_write_request *request9)
1798 {
1799 uint32_t len;
1800 char * p;
1801
1802 len = request3->data_out.data_out_len;
1803
1804 p = NDMOS_API_MALLOC (len);
1805 if (!p) {
1806 return -1;
1807 }
1808
1809 NDMOS_API_BCOPY (request3->data_out.data_out_val, p, len);
1810
1811 request9->data_out.data_out_val = p;
1812 request9->data_out.data_out_len = len;
1813
1814 return 0;
1815 }
1816
1817 int
ndmp_9to3_tape_write_request(ndmp9_tape_write_request * request9,ndmp3_tape_write_request * request3)1818 ndmp_9to3_tape_write_request (
1819 ndmp9_tape_write_request *request9,
1820 ndmp3_tape_write_request *request3)
1821 {
1822 uint32_t len;
1823 char * p;
1824
1825 len = request9->data_out.data_out_len;
1826
1827 p = NDMOS_API_MALLOC (len);
1828 if (!p) {
1829 return -1;
1830 }
1831
1832 NDMOS_API_BCOPY (request9->data_out.data_out_val, p, len);
1833
1834 request3->data_out.data_out_val = p;
1835 request3->data_out.data_out_len = len;
1836
1837 return 0;
1838 }
1839
1840 int
ndmp_3to9_tape_write_reply(ndmp3_tape_write_reply * reply3,ndmp9_tape_write_reply * reply9)1841 ndmp_3to9_tape_write_reply (
1842 ndmp3_tape_write_reply *reply3,
1843 ndmp9_tape_write_reply *reply9)
1844 {
1845 CNVT_E_TO_9 (reply3, reply9, error, ndmp_39_error);
1846 CNVT_TO_9 (reply3, reply9, count);
1847 return 0;
1848 }
1849
1850 int
ndmp_9to3_tape_write_reply(ndmp9_tape_write_reply * reply9,ndmp3_tape_write_reply * reply3)1851 ndmp_9to3_tape_write_reply (
1852 ndmp9_tape_write_reply *reply9,
1853 ndmp3_tape_write_reply *reply3)
1854 {
1855 CNVT_E_FROM_9 (reply3, reply9, error, ndmp_39_error);
1856 CNVT_FROM_9 (reply3, reply9, count);
1857 return 0;
1858 }
1859
1860
1861 /*
1862 * ndmp_tape_read
1863 */
1864
1865 int
ndmp_3to9_tape_read_request(ndmp3_tape_read_request * request3,ndmp9_tape_read_request * request9)1866 ndmp_3to9_tape_read_request (
1867 ndmp3_tape_read_request *request3,
1868 ndmp9_tape_read_request *request9)
1869 {
1870 CNVT_TO_9 (request3, request9, count);
1871 return 0;
1872 }
1873
1874 int
ndmp_9to3_tape_read_request(ndmp9_tape_read_request * request9,ndmp3_tape_read_request * request3)1875 ndmp_9to3_tape_read_request (
1876 ndmp9_tape_read_request *request9,
1877 ndmp3_tape_read_request *request3)
1878 {
1879 CNVT_FROM_9 (request3, request9, count);
1880 return 0;
1881 }
1882
1883 int
ndmp_3to9_tape_read_reply(ndmp3_tape_read_reply * reply3,ndmp9_tape_read_reply * reply9)1884 ndmp_3to9_tape_read_reply (
1885 ndmp3_tape_read_reply *reply3,
1886 ndmp9_tape_read_reply *reply9)
1887 {
1888 uint32_t len;
1889 char * p;
1890
1891 CNVT_E_TO_9 (reply3, reply9, error, ndmp_39_error);
1892
1893 len = reply3->data_in.data_in_len;
1894 if (len > 0) {
1895 p = NDMOS_API_MALLOC (len);
1896 if (!p) {
1897 return -1;
1898 }
1899 NDMOS_API_BCOPY (reply3->data_in.data_in_val, p, len);
1900 } else {
1901 p = 0;
1902 len = 0;
1903 }
1904
1905 reply9->data_in.data_in_len = len;
1906 reply9->data_in.data_in_val = p;
1907
1908 return 0;
1909 }
1910
1911 int
ndmp_9to3_tape_read_reply(ndmp9_tape_read_reply * reply9,ndmp3_tape_read_reply * reply3)1912 ndmp_9to3_tape_read_reply (
1913 ndmp9_tape_read_reply *reply9,
1914 ndmp3_tape_read_reply *reply3)
1915 {
1916 uint32_t len;
1917 char * p;
1918
1919 CNVT_E_FROM_9 (reply3, reply9, error, ndmp_39_error);
1920
1921 len = reply9->data_in.data_in_len;
1922 if (len > 0) {
1923 p = NDMOS_API_MALLOC (len);
1924 if (!p) {
1925 return -1;
1926 }
1927 NDMOS_API_BCOPY (reply9->data_in.data_in_val, p, len);
1928 } else {
1929 p = 0;
1930 len = 0;
1931 }
1932
1933 reply3->data_in.data_in_len = len;
1934 reply3->data_in.data_in_val = p;
1935
1936 return 0;
1937 }
1938
1939 /*
1940 * ndmp_tape_execute_cdb
1941 * see SCSI INTERFACES above
1942 */
1943
1944
1945
1946
1947 /*
1948 * MOVER INTERFACES
1949 ****************************************************************
1950 */
1951
1952 /*
1953 * ndmp_mover_get_state
1954 * no args request
1955 */
1956
1957
1958 struct enum_conversion ndmp_39_mover_mode[] = {
1959 { NDMP_INVALID_GENERAL, NDMP_INVALID_GENERAL, }, /* default */
1960 { NDMP3_MOVER_MODE_READ, NDMP9_MOVER_MODE_READ },
1961 { NDMP3_MOVER_MODE_WRITE, NDMP9_MOVER_MODE_WRITE },
1962
1963 END_ENUM_CONVERSION_TABLE
1964 };
1965
1966 struct enum_conversion ndmp_39_mover_state[] = {
1967 { NDMP_INVALID_GENERAL, NDMP_INVALID_GENERAL, }, /* default */
1968 { NDMP3_MOVER_STATE_IDLE, NDMP9_MOVER_STATE_IDLE },
1969 { NDMP3_MOVER_STATE_LISTEN, NDMP9_MOVER_STATE_LISTEN },
1970 { NDMP3_MOVER_STATE_ACTIVE, NDMP9_MOVER_STATE_ACTIVE },
1971 { NDMP3_MOVER_STATE_PAUSED, NDMP9_MOVER_STATE_PAUSED },
1972 { NDMP3_MOVER_STATE_HALTED, NDMP9_MOVER_STATE_HALTED },
1973
1974 /* alias */
1975 { NDMP3_MOVER_STATE_ACTIVE, NDMP9_MOVER_STATE_STANDBY },
1976
1977 END_ENUM_CONVERSION_TABLE
1978 };
1979
1980 struct enum_conversion ndmp_39_mover_pause_reason[] = {
1981 { NDMP_INVALID_GENERAL, NDMP_INVALID_GENERAL, }, /* default */
1982 { NDMP3_MOVER_PAUSE_NA, NDMP9_MOVER_PAUSE_NA },
1983 { NDMP3_MOVER_PAUSE_EOM, NDMP9_MOVER_PAUSE_EOM },
1984 { NDMP3_MOVER_PAUSE_EOF, NDMP9_MOVER_PAUSE_EOF },
1985 { NDMP3_MOVER_PAUSE_SEEK, NDMP9_MOVER_PAUSE_SEEK },
1986 { NDMP3_MOVER_PAUSE_MEDIA_ERROR, NDMP9_MOVER_PAUSE_MEDIA_ERROR },
1987 { NDMP3_MOVER_PAUSE_EOW, NDMP9_MOVER_PAUSE_EOW },
1988 END_ENUM_CONVERSION_TABLE
1989 };
1990
1991 struct enum_conversion ndmp_39_mover_halt_reason[] = {
1992 { NDMP_INVALID_GENERAL, NDMP_INVALID_GENERAL, }, /* default */
1993 { NDMP3_MOVER_HALT_NA, NDMP9_MOVER_HALT_NA },
1994 { NDMP3_MOVER_HALT_CONNECT_CLOSED, NDMP9_MOVER_HALT_CONNECT_CLOSED },
1995 { NDMP3_MOVER_HALT_ABORTED, NDMP9_MOVER_HALT_ABORTED },
1996 { NDMP3_MOVER_HALT_INTERNAL_ERROR, NDMP9_MOVER_HALT_INTERNAL_ERROR },
1997 { NDMP3_MOVER_HALT_CONNECT_ERROR, NDMP9_MOVER_HALT_CONNECT_ERROR },
1998 END_ENUM_CONVERSION_TABLE
1999 };
2000
2001
2002 extern int
ndmp_3to9_mover_get_state_reply(ndmp3_mover_get_state_reply * reply3,ndmp9_mover_get_state_reply * reply9)2003 ndmp_3to9_mover_get_state_reply (
2004 ndmp3_mover_get_state_reply *reply3,
2005 ndmp9_mover_get_state_reply *reply9)
2006 {
2007 CNVT_E_TO_9 (reply3, reply9, error, ndmp_39_error);
2008 CNVT_E_TO_9 (reply3, reply9, state, ndmp_39_mover_state);
2009 CNVT_E_TO_9 (reply3, reply9, pause_reason, ndmp_39_mover_pause_reason);
2010 CNVT_E_TO_9 (reply3, reply9, halt_reason, ndmp_39_mover_halt_reason);
2011
2012 CNVT_TO_9 (reply3, reply9, record_size);
2013 CNVT_TO_9 (reply3, reply9, record_num);
2014 CNVT_TO_9x (reply3, reply9, data_written, bytes_moved);
2015 CNVT_TO_9 (reply3, reply9, seek_position);
2016 CNVT_TO_9 (reply3, reply9, bytes_left_to_read);
2017 CNVT_TO_9 (reply3, reply9, window_offset);
2018 CNVT_TO_9 (reply3, reply9, window_length);
2019
2020 ndmp_3to9_addr (&reply3->data_connection_addr,
2021 &reply9->data_connection_addr);
2022
2023 return 0;
2024 }
2025
2026 extern int
ndmp_9to3_mover_get_state_reply(ndmp9_mover_get_state_reply * reply9,ndmp3_mover_get_state_reply * reply3)2027 ndmp_9to3_mover_get_state_reply (
2028 ndmp9_mover_get_state_reply *reply9,
2029 ndmp3_mover_get_state_reply *reply3)
2030 {
2031 CNVT_E_FROM_9 (reply3, reply9, error, ndmp_39_error);
2032 CNVT_E_FROM_9 (reply3, reply9, state, ndmp_39_mover_state);
2033 CNVT_E_FROM_9 (reply3, reply9, pause_reason,
2034 ndmp_39_mover_pause_reason);
2035 CNVT_E_FROM_9 (reply3, reply9, halt_reason,
2036 ndmp_39_mover_halt_reason);
2037
2038 CNVT_FROM_9 (reply3, reply9, record_size);
2039 CNVT_FROM_9 (reply3, reply9, record_num);
2040 CNVT_FROM_9x (reply3, reply9, data_written, bytes_moved);
2041 CNVT_FROM_9 (reply3, reply9, seek_position);
2042 CNVT_FROM_9 (reply3, reply9, bytes_left_to_read);
2043 CNVT_FROM_9 (reply3, reply9, window_offset);
2044 CNVT_FROM_9 (reply3, reply9, window_length);
2045
2046 ndmp_9to3_addr (&reply9->data_connection_addr,
2047 &reply3->data_connection_addr);
2048
2049 return 0;
2050 }
2051
2052
2053 /*
2054 * ndmp_mover_listen
2055 */
2056
2057 int
ndmp_3to9_mover_listen_request(ndmp3_mover_listen_request * request3,ndmp9_mover_listen_request * request9)2058 ndmp_3to9_mover_listen_request (
2059 ndmp3_mover_listen_request *request3,
2060 ndmp9_mover_listen_request *request9)
2061 {
2062 int rc;
2063
2064 rc = CNVT_E_TO_9 (request3, request9, mode, ndmp_39_mover_mode);
2065 if (rc == NDMP_INVALID_GENERAL) {
2066 CNVT_TO_9 (request3, request9, mode);
2067 }
2068 rc = CNVT_E_TO_9 (request3, request9, addr_type, ndmp_39_addr_type);
2069 if (rc == NDMP_INVALID_GENERAL) {
2070 CNVT_TO_9 (request3, request9, addr_type);
2071 }
2072
2073 return 0;
2074 }
2075
2076 int
ndmp_9to3_mover_listen_request(ndmp9_mover_listen_request * request9,ndmp3_mover_listen_request * request3)2077 ndmp_9to3_mover_listen_request (
2078 ndmp9_mover_listen_request *request9,
2079 ndmp3_mover_listen_request *request3)
2080 {
2081 int rc;
2082
2083 rc = CNVT_E_FROM_9 (request3, request9, mode, ndmp_39_mover_mode);
2084 if (rc == NDMP_INVALID_GENERAL) {
2085 CNVT_FROM_9 (request3, request9, mode);
2086 }
2087 rc = CNVT_E_FROM_9 (request3, request9, addr_type, ndmp_39_addr_type);
2088 if (rc == NDMP_INVALID_GENERAL) {
2089 CNVT_FROM_9 (request3, request9, addr_type);
2090 }
2091
2092 return 0;
2093 }
2094
2095 int
ndmp_3to9_mover_listen_reply(ndmp3_mover_listen_reply * reply3,ndmp9_mover_listen_reply * reply9)2096 ndmp_3to9_mover_listen_reply (
2097 ndmp3_mover_listen_reply *reply3,
2098 ndmp9_mover_listen_reply *reply9)
2099 {
2100 int n_error = 0;
2101
2102 CNVT_E_TO_9 (reply3, reply9, error, ndmp_39_error);
2103
2104 n_error += ndmp_3to9_addr (&reply3->data_connection_addr,
2105 &reply9->data_connection_addr);
2106
2107 return n_error;
2108 }
2109
2110 int
ndmp_9to3_mover_listen_reply(ndmp9_mover_listen_reply * reply9,ndmp3_mover_listen_reply * reply3)2111 ndmp_9to3_mover_listen_reply (
2112 ndmp9_mover_listen_reply *reply9,
2113 ndmp3_mover_listen_reply *reply3)
2114 {
2115 int n_error = 0;
2116
2117 CNVT_E_FROM_9 (reply3, reply9, error, ndmp_39_error);
2118
2119 n_error += ndmp_9to3_addr (&reply9->data_connection_addr,
2120 &reply3->data_connection_addr);
2121
2122 return n_error;
2123 }
2124
2125 /*
2126 * ndmp_mover_connect
2127 * just error reply
2128 */
2129
2130 int
ndmp_3to9_mover_connect_request(ndmp3_mover_connect_request * request3,ndmp9_mover_connect_request * request9)2131 ndmp_3to9_mover_connect_request (
2132 ndmp3_mover_connect_request *request3,
2133 ndmp9_mover_connect_request *request9)
2134 {
2135 int rc;
2136
2137 rc = CNVT_E_TO_9 (request3, request9, mode, ndmp_39_mover_mode);
2138 if (rc == NDMP_INVALID_GENERAL) {
2139 CNVT_TO_9 (request3, request9, mode);
2140 }
2141 return ndmp_3to9_addr (&request3->addr, &request9->addr);
2142 }
2143
2144 int
ndmp_9to3_mover_connect_request(ndmp9_mover_connect_request * request9,ndmp3_mover_connect_request * request3)2145 ndmp_9to3_mover_connect_request (
2146 ndmp9_mover_connect_request *request9,
2147 ndmp3_mover_connect_request *request3)
2148 {
2149 int rc;
2150
2151 rc = CNVT_E_FROM_9 (request3, request9, mode, ndmp_39_mover_mode);
2152 if (rc == NDMP_INVALID_GENERAL) {
2153 CNVT_FROM_9 (request3, request9, mode);
2154 }
2155 return ndmp_9to3_addr (&request9->addr, &request3->addr);
2156 }
2157
2158
2159
2160 /*
2161 * ndmp_mover_continue
2162 * no arg request, just error reply
2163 */
2164
2165 /*
2166 * ndmp_mover_abort
2167 * no args request, just error reply
2168 */
2169
2170 /*
2171 * ndmp_mover_stop
2172 * no args request, just error reply
2173 */
2174
2175
2176 /*
2177 * ndmp_mover_set_window
2178 * just error reply
2179 */
2180
2181 int
ndmp_3to9_mover_set_window_request(ndmp3_mover_set_window_request * request3,ndmp9_mover_set_window_request * request9)2182 ndmp_3to9_mover_set_window_request (
2183 ndmp3_mover_set_window_request *request3,
2184 ndmp9_mover_set_window_request *request9)
2185 {
2186 CNVT_TO_9 (request3, request9, offset);
2187 CNVT_TO_9 (request3, request9, length);
2188 return 0;
2189 }
2190
2191 int
ndmp_9to3_mover_set_window_request(ndmp9_mover_set_window_request * request9,ndmp3_mover_set_window_request * request3)2192 ndmp_9to3_mover_set_window_request (
2193 ndmp9_mover_set_window_request *request9,
2194 ndmp3_mover_set_window_request *request3)
2195 {
2196 CNVT_FROM_9 (request3, request9, offset);
2197 CNVT_FROM_9 (request3, request9, length);
2198 return 0;
2199 }
2200
2201
2202 /*
2203 * ndmp_mover_read
2204 * just error reply
2205 */
2206
2207 int
ndmp_3to9_mover_read_request(ndmp3_mover_read_request * request3,ndmp9_mover_read_request * request9)2208 ndmp_3to9_mover_read_request (
2209 ndmp3_mover_read_request *request3,
2210 ndmp9_mover_read_request *request9)
2211 {
2212 CNVT_TO_9 (request3, request9, offset);
2213 CNVT_TO_9 (request3, request9, length);
2214 return 0;
2215 }
2216
2217 int
ndmp_9to3_mover_read_request(ndmp9_mover_read_request * request9,ndmp3_mover_read_request * request3)2218 ndmp_9to3_mover_read_request (
2219 ndmp9_mover_read_request *request9,
2220 ndmp3_mover_read_request *request3)
2221 {
2222 CNVT_FROM_9 (request3, request9, offset);
2223 CNVT_FROM_9 (request3, request9, length);
2224 return 0;
2225 }
2226
2227 /*
2228 * ndmp_mover_close
2229 * no args request, just error reply
2230 */
2231
2232 /*
2233 * ndmp_mover_set_record_size
2234 * just error reply
2235 */
2236
2237 int
ndmp_3to9_mover_set_record_size_request(ndmp3_mover_set_record_size_request * request3,ndmp9_mover_set_record_size_request * request9)2238 ndmp_3to9_mover_set_record_size_request (
2239 ndmp3_mover_set_record_size_request *request3,
2240 ndmp9_mover_set_record_size_request *request9)
2241 {
2242 CNVT_TO_9x (request3, request9, len, record_size);
2243 return 0;
2244 }
2245
2246 int
ndmp_9to3_mover_set_record_size_request(ndmp9_mover_set_record_size_request * request9,ndmp3_mover_set_record_size_request * request3)2247 ndmp_9to3_mover_set_record_size_request (
2248 ndmp9_mover_set_record_size_request *request9,
2249 ndmp3_mover_set_record_size_request *request3)
2250 {
2251 CNVT_FROM_9x (request3, request9, len, record_size);
2252 return 0;
2253 }
2254
2255
2256 /*
2257 * DATA INTERFACES
2258 ****************************************************************
2259 */
2260
2261
2262 int
ndmp_3to9_name(ndmp3_name * name3,ndmp9_name * name9)2263 ndmp_3to9_name (
2264 ndmp3_name *name3,
2265 ndmp9_name *name9)
2266 {
2267 char buf[1024];
2268 int cnt;
2269
2270 cnt = sizeof(buf) - 1;
2271 name9->original_path = NDMOS_API_STRDUP(name3->original_path);
2272 if (name3->new_name && *name3->new_name && *name3->destination_dir) {
2273 snprintf (buf, cnt, "%s/%s", name3->destination_dir, name3->new_name);
2274 } else if (name3->new_name && *name3->new_name) {
2275 snprintf (buf, cnt, "/%s", name3->new_name);
2276 } else {
2277 strncpy (buf, name3->destination_dir, cnt);
2278 }
2279 buf[cnt] = '\0';
2280 name9->destination_path = NDMOS_API_STRDUP(buf);
2281
2282 /* per the following email's on the NDMP tech mailing on
2283 * Apr. 10 & 11 2000 and Feb. 21, 2001 with matching
2284 * references in the V3.1.3 specification:
2285 *
2286 * V2 and V4 are close in behavior but V3 does the following:
2287 *
2288 * If new_name is not NULL then the destination path is
2289 * destination_path = destination_dir PLUS new_name
2290 * otherwise
2291 * destination_path = destination_dir PLUS original_path
2292 * and original_path is missing the trailing component.
2293 */
2294 if (name3->new_name && *name3->new_name) {
2295 if (*name3->original_path) {
2296 snprintf (buf, cnt, "%s/%s", name3->original_path, name3->new_name);
2297 } else {
2298 strncpy (buf, name3->new_name, cnt);
2299 }
2300 buf[cnt] = '\0';
2301 name9->original_path = NDMOS_API_STRDUP(buf);
2302 } else {
2303 name9->original_path = NDMOS_API_STRDUP(name3->original_path);
2304 }
2305
2306 if (name3->new_name && *name3->new_name) {
2307 if (*name3->destination_dir) {
2308 snprintf (buf, cnt, "%s/%s", name3->destination_dir, name3->new_name);
2309 } else {
2310 strncpy (buf, name3->new_name, cnt);
2311 }
2312 buf[cnt] = '\0';
2313 name9->original_path = NDMOS_API_STRDUP(buf);
2314 } else {
2315 if (*name3->destination_dir) {
2316 snprintf (buf, cnt, "%s/%s", name3->destination_dir, name3->original_path);
2317 } else {
2318 strncpy (buf, name3->original_path, cnt);
2319 }
2320 buf[cnt] = '\0';
2321 }
2322 name9->destination_path = NDMOS_API_STRDUP(buf);
2323
2324 name9->other_name = NDMOS_API_STRDUP (name3->other_name);
2325 name9->node = name3->node;
2326
2327 if (name3->fh_info != NDMP_INVALID_U_QUAD) {
2328 name9->fh_info.valid = NDMP9_VALIDITY_VALID;
2329 name9->fh_info.value = name3->fh_info;
2330 } else {
2331 name9->fh_info.valid = NDMP9_VALIDITY_INVALID;
2332 name9->fh_info.value = NDMP_INVALID_U_QUAD;
2333 }
2334
2335 return 0;
2336 }
2337
2338 int
ndmp_9to3_name(ndmp9_name * name9,ndmp3_name * name3)2339 ndmp_9to3_name (
2340 ndmp9_name *name9,
2341 ndmp3_name *name3)
2342 {
2343 char buf[1024];
2344 int olen, dlen, offset;
2345
2346 /* see comment in ndmp_3to9_name() above */
2347
2348 if (!strcmp(name9->original_path,".")) {
2349 // special case
2350 name3->original_path = NDMOS_API_STRDUP(name9->original_path);
2351 name3->destination_dir = NDMOS_API_STRDUP(name9->destination_path);
2352 name3->new_name = NDMOS_API_STRDUP("");
2353 } else {
2354 olen = strlen(name9->original_path);
2355 dlen = strlen(name9->destination_path);
2356 offset = dlen - olen;
2357 if ((olen < dlen) && (!strcmp(name9->original_path,
2358 &name9->destination_path[offset]))) {
2359 /* original path part of destination path */
2360 name3->original_path = NDMOS_API_STRDUP(name9->original_path);
2361 *buf = 0;
2362 strncat(buf, name9->destination_path, offset);
2363 name3->destination_dir = NDMOS_API_STRDUP(buf);
2364 name3->new_name = NDMOS_API_STRDUP("");
2365 } else {
2366 name3->original_path = NDMOS_API_STRDUP(name9->original_path);
2367 name3->destination_dir = NDMOS_API_STRDUP("");
2368 name3->new_name = NDMOS_API_STRDUP(name9->destination_path);
2369 }
2370 }
2371
2372 name3->other_name = NDMOS_API_STRDUP (name9->other_name);
2373 name3->node = name9->node;
2374
2375 if (name9->fh_info.valid == NDMP9_VALIDITY_VALID) {
2376 name3->fh_info = name9->fh_info.value;
2377 } else {
2378 name3->fh_info = NDMP_INVALID_U_QUAD;
2379 }
2380
2381 return 0;
2382 }
2383
2384 int
ndmp_3to9_name_vec(ndmp3_name * name3,ndmp9_name * name9,unsigned n_name)2385 ndmp_3to9_name_vec (
2386 ndmp3_name *name3,
2387 ndmp9_name *name9,
2388 unsigned n_name)
2389 {
2390 unsigned int i;
2391
2392 for (i = 0; i < n_name; i++)
2393 ndmp_3to9_name (&name3[i], &name9[i]);
2394
2395 return 0;
2396 }
2397
2398 int
ndmp_9to3_name_vec(ndmp9_name * name9,ndmp3_name * name3,unsigned n_name)2399 ndmp_9to3_name_vec (
2400 ndmp9_name *name9,
2401 ndmp3_name *name3,
2402 unsigned n_name)
2403 {
2404 unsigned int i;
2405
2406 for (i = 0; i < n_name; i++)
2407 ndmp_9to3_name (&name9[i], &name3[i]);
2408
2409 return 0;
2410 }
2411
2412 int
ndmp_3to9_name_vec_dup(ndmp3_name * name3,ndmp9_name ** name9_p,unsigned n_name)2413 ndmp_3to9_name_vec_dup (
2414 ndmp3_name *name3,
2415 ndmp9_name **name9_p,
2416 unsigned n_name)
2417 {
2418 *name9_p = NDMOS_MACRO_NEWN (ndmp9_name, n_name);
2419 if (!*name9_p)
2420 return -1;
2421
2422 return ndmp_3to9_name_vec (name3, *name9_p, n_name);
2423 }
2424
2425 int
ndmp_9to3_name_vec_dup(ndmp9_name * name9,ndmp3_name ** name3_p,unsigned n_name)2426 ndmp_9to3_name_vec_dup (
2427 ndmp9_name *name9,
2428 ndmp3_name **name3_p,
2429 unsigned n_name)
2430 {
2431 *name3_p = NDMOS_MACRO_NEWN (ndmp3_name, n_name);
2432 if (!*name3_p)
2433 return -1;
2434
2435 return ndmp_9to3_name_vec (name9, *name3_p, n_name);
2436 }
2437
2438 /*
2439 * ndmp_data_get_state
2440 * no args request
2441 */
2442
2443 struct enum_conversion ndmp_39_data_operation[] = {
2444 { NDMP_INVALID_GENERAL, NDMP_INVALID_GENERAL, }, /* default */
2445 { NDMP3_DATA_OP_NOACTION, NDMP9_DATA_OP_NOACTION },
2446 { NDMP3_DATA_OP_BACKUP, NDMP9_DATA_OP_BACKUP },
2447 { NDMP3_DATA_OP_RESTORE, NDMP9_DATA_OP_RECOVER },
2448 { NDMP3_DATA_OP_RESTORE_FILEHIST, NDMP9_DATA_OP_RECOVER_FILEHIST },
2449 END_ENUM_CONVERSION_TABLE
2450 };
2451
2452 struct enum_conversion ndmp_39_data_state[] = {
2453 { NDMP_INVALID_GENERAL, NDMP_INVALID_GENERAL, }, /* default */
2454 { NDMP3_DATA_STATE_IDLE, NDMP9_DATA_STATE_IDLE },
2455 { NDMP3_DATA_STATE_ACTIVE, NDMP9_DATA_STATE_ACTIVE },
2456 { NDMP3_DATA_STATE_HALTED, NDMP9_DATA_STATE_HALTED },
2457 { NDMP3_DATA_STATE_CONNECTED, NDMP9_DATA_STATE_CONNECTED },
2458 { NDMP3_DATA_STATE_LISTEN, NDMP9_DATA_STATE_LISTEN },
2459
2460 END_ENUM_CONVERSION_TABLE
2461 };
2462
2463 struct enum_conversion ndmp_39_data_halt_reason[] = {
2464 { NDMP_INVALID_GENERAL, NDMP_INVALID_GENERAL, }, /* default */
2465 { NDMP3_DATA_HALT_NA, NDMP9_DATA_HALT_NA },
2466 { NDMP3_DATA_HALT_SUCCESSFUL, NDMP9_DATA_HALT_SUCCESSFUL },
2467 { NDMP3_DATA_HALT_ABORTED, NDMP9_DATA_HALT_ABORTED },
2468 { NDMP3_DATA_HALT_INTERNAL_ERROR, NDMP9_DATA_HALT_INTERNAL_ERROR },
2469 { NDMP3_DATA_HALT_CONNECT_ERROR, NDMP9_DATA_HALT_CONNECT_ERROR },
2470 END_ENUM_CONVERSION_TABLE
2471 };
2472
2473 extern int
ndmp_3to9_data_get_state_reply(ndmp3_data_get_state_reply * reply3,ndmp9_data_get_state_reply * reply9)2474 ndmp_3to9_data_get_state_reply (
2475 ndmp3_data_get_state_reply *reply3,
2476 ndmp9_data_get_state_reply *reply9)
2477 {
2478 CNVT_E_TO_9 (reply3, reply9, error, ndmp_39_error);
2479 CNVT_E_TO_9 (reply3, reply9, operation, ndmp_39_data_operation);
2480 CNVT_E_TO_9 (reply3, reply9, state, ndmp_39_data_state);
2481 CNVT_E_TO_9 (reply3, reply9, halt_reason, ndmp_39_data_halt_reason);
2482
2483 CNVT_TO_9 (reply3, reply9, bytes_processed);
2484
2485 CNVT_VUQ_TO_9 (reply3, reply9, est_bytes_remain);
2486 CNVT_VUL_TO_9 (reply3, reply9, est_time_remain);
2487
2488 ndmp_3to9_addr (&reply3->data_connection_addr,
2489 &reply9->data_connection_addr);
2490
2491 CNVT_TO_9 (reply3, reply9, read_offset);
2492 CNVT_TO_9 (reply3, reply9, read_length);
2493
2494 return 0;
2495 }
2496
2497 extern int
ndmp_9to3_data_get_state_reply(ndmp9_data_get_state_reply * reply9,ndmp3_data_get_state_reply * reply3)2498 ndmp_9to3_data_get_state_reply (
2499 ndmp9_data_get_state_reply *reply9,
2500 ndmp3_data_get_state_reply *reply3)
2501 {
2502 CNVT_E_FROM_9 (reply3, reply9, error, ndmp_39_error);
2503 CNVT_E_FROM_9 (reply3, reply9, operation, ndmp_39_data_operation);
2504 CNVT_E_FROM_9 (reply3, reply9, state, ndmp_39_data_state);
2505 CNVT_E_FROM_9 (reply3, reply9, halt_reason, ndmp_39_data_halt_reason);
2506
2507 CNVT_FROM_9 (reply3, reply9, bytes_processed);
2508
2509 CNVT_VUQ_FROM_9 (reply3, reply9, est_bytes_remain);
2510 CNVT_VUL_FROM_9 (reply3, reply9, est_time_remain);
2511
2512 ndmp_9to3_addr (&reply9->data_connection_addr,
2513 &reply3->data_connection_addr);
2514
2515 CNVT_FROM_9 (reply3, reply9, read_offset);
2516 CNVT_FROM_9 (reply3, reply9, read_length);
2517
2518 return 0;
2519 }
2520
2521
2522 /*
2523 * ndmp_data_start_backup
2524 * just error reply
2525 */
2526
2527 int
ndmp_3to9_data_start_backup_request(ndmp3_data_start_backup_request * request3,ndmp9_data_start_backup_request * request9)2528 ndmp_3to9_data_start_backup_request (
2529 ndmp3_data_start_backup_request *request3,
2530 ndmp9_data_start_backup_request *request9)
2531 {
2532 int n_error = 0;
2533
2534 CNVT_STRDUP_TO_9 (request3, request9, bu_type);
2535
2536 ndmp_3to9_pval_vec_dup (request3->env.env_val,
2537 &request9->env.env_val,
2538 request3->env.env_len);
2539
2540 request9->env.env_len = request3->env.env_len;
2541
2542 request9->addr.addr_type = NDMP9_ADDR_AS_CONNECTED;
2543
2544 return n_error;
2545 }
2546
2547 int
ndmp_9to3_data_start_backup_request(ndmp9_data_start_backup_request * request9,ndmp3_data_start_backup_request * request3)2548 ndmp_9to3_data_start_backup_request (
2549 ndmp9_data_start_backup_request *request9,
2550 ndmp3_data_start_backup_request *request3)
2551 {
2552 int n_error = 0;
2553
2554 CNVT_STRDUP_FROM_9 (request3, request9, bu_type);
2555
2556 ndmp_9to3_pval_vec_dup (request9->env.env_val,
2557 &request3->env.env_val,
2558 request9->env.env_len);
2559
2560 request3->env.env_len = request9->env.env_len;
2561
2562 return n_error;
2563 }
2564
2565
2566 /*
2567 * ndmp_data_start_recover
2568 * ndmp_data_start_recover_filehist
2569 * just error reply
2570 */
2571
2572 int
ndmp_3to9_data_start_recover_request(ndmp3_data_start_recover_request * request3,ndmp9_data_start_recover_request * request9)2573 ndmp_3to9_data_start_recover_request (
2574 ndmp3_data_start_recover_request *request3,
2575 ndmp9_data_start_recover_request *request9)
2576 {
2577 int n_error = 0;
2578
2579 CNVT_STRDUP_TO_9 (request3, request9, bu_type);
2580
2581 ndmp_3to9_pval_vec_dup (request3->env.env_val,
2582 &request9->env.env_val,
2583 request3->env.env_len);
2584
2585 request9->env.env_len = request3->env.env_len;
2586
2587 ndmp_3to9_name_vec_dup (request3->nlist.nlist_val,
2588 &request9->nlist.nlist_val,
2589 request3->nlist.nlist_len);
2590
2591 request9->nlist.nlist_len = request3->nlist.nlist_len;
2592
2593 request9->addr.addr_type = NDMP9_ADDR_AS_CONNECTED;
2594
2595 return n_error;
2596 }
2597
2598 int
ndmp_9to3_data_start_recover_request(ndmp9_data_start_recover_request * request9,ndmp3_data_start_recover_request * request3)2599 ndmp_9to3_data_start_recover_request (
2600 ndmp9_data_start_recover_request *request9,
2601 ndmp3_data_start_recover_request *request3)
2602 {
2603 int n_error = 0;
2604
2605 CNVT_STRDUP_FROM_9 (request3, request9, bu_type);
2606
2607 ndmp_9to3_pval_vec_dup (request9->env.env_val,
2608 &request3->env.env_val,
2609 request9->env.env_len);
2610
2611 request3->env.env_len = request9->env.env_len;
2612
2613 ndmp_9to3_name_vec_dup (request9->nlist.nlist_val,
2614 &request3->nlist.nlist_val,
2615 request9->nlist.nlist_len);
2616
2617 request3->nlist.nlist_len = request9->nlist.nlist_len;
2618
2619
2620 return n_error;
2621 }
2622
2623
2624 /*
2625 * ndmp_data_abort
2626 * no args request, just error reply
2627 */
2628
2629 /*
2630 * ndmp_data_get_env
2631 * no args request
2632 */
2633
2634 int
ndmp_3to9_data_get_env_reply(ndmp3_data_get_env_reply * reply3,ndmp9_data_get_env_reply * reply9)2635 ndmp_3to9_data_get_env_reply (
2636 ndmp3_data_get_env_reply *reply3,
2637 ndmp9_data_get_env_reply *reply9)
2638 {
2639 CNVT_E_TO_9 (reply3, reply9, error, ndmp_39_error);
2640
2641 ndmp_3to9_pval_vec_dup (reply3->env.env_val,
2642 &reply9->env.env_val,
2643 reply3->env.env_len);
2644
2645 reply9->env.env_len = reply3->env.env_len;
2646
2647 return 0;
2648 }
2649
2650 int
ndmp_9to3_data_get_env_reply(ndmp9_data_get_env_reply * reply9,ndmp3_data_get_env_reply * reply3)2651 ndmp_9to3_data_get_env_reply (
2652 ndmp9_data_get_env_reply *reply9,
2653 ndmp3_data_get_env_reply *reply3)
2654 {
2655 CNVT_E_FROM_9 (reply3, reply9, error, ndmp_39_error);
2656
2657 ndmp_9to3_pval_vec_dup (reply9->env.env_val,
2658 &reply3->env.env_val,
2659 reply9->env.env_len);
2660
2661 reply3->env.env_len = reply9->env.env_len;
2662
2663 return 0;
2664 }
2665
2666
2667 /*
2668 * ndmp_data_stop
2669 * no args request, just error reply
2670 */
2671
2672 /*
2673 * ndmp_data_listen
2674 */
2675
2676 int
ndmp_3to9_data_listen_request(ndmp3_data_listen_request * request3,ndmp9_data_listen_request * request9)2677 ndmp_3to9_data_listen_request (
2678 ndmp3_data_listen_request *request3,
2679 ndmp9_data_listen_request *request9)
2680 {
2681 int rc;
2682
2683 rc = CNVT_E_TO_9 (request3, request9, addr_type, ndmp_39_addr_type);
2684 if (rc == NDMP_INVALID_GENERAL) {
2685 CNVT_TO_9 (request3, request9, addr_type);
2686 }
2687
2688 return 0;
2689 }
2690
2691 int
ndmp_9to3_data_listen_request(ndmp9_data_listen_request * request9,ndmp3_data_listen_request * request3)2692 ndmp_9to3_data_listen_request (
2693 ndmp9_data_listen_request *request9,
2694 ndmp3_data_listen_request *request3)
2695 {
2696 int rc;
2697
2698 rc = CNVT_E_FROM_9 (request3, request9, addr_type, ndmp_39_addr_type);
2699 if (rc == NDMP_INVALID_GENERAL) {
2700 CNVT_FROM_9 (request3, request9, addr_type);
2701 }
2702
2703 return 0;
2704 }
2705
2706 int
ndmp_3to9_data_listen_reply(ndmp3_data_listen_reply * reply3,ndmp9_data_listen_reply * reply9)2707 ndmp_3to9_data_listen_reply (
2708 ndmp3_data_listen_reply *reply3,
2709 ndmp9_data_listen_reply *reply9)
2710 {
2711 int n_error = 0;
2712
2713 CNVT_E_TO_9 (reply3, reply9, error, ndmp_39_error);
2714
2715 n_error += ndmp_3to9_addr (&reply3->data_connection_addr,
2716 &reply9->data_connection_addr);
2717
2718 return n_error;
2719 }
2720
2721 int
ndmp_9to3_data_listen_reply(ndmp9_data_listen_reply * reply9,ndmp3_data_listen_reply * reply3)2722 ndmp_9to3_data_listen_reply (
2723 ndmp9_data_listen_reply *reply9,
2724 ndmp3_data_listen_reply *reply3)
2725 {
2726 int n_error = 0;
2727
2728 CNVT_E_FROM_9 (reply3, reply9, error, ndmp_39_error);
2729
2730 n_error += ndmp_9to3_addr (&reply9->data_connection_addr,
2731 &reply3->data_connection_addr);
2732
2733 return n_error;
2734 }
2735
2736
2737 /*
2738 * ndmp_data_connect
2739 * just error reply
2740 */
2741
2742 int
ndmp_3to9_data_connect_request(ndmp3_data_connect_request * request3,ndmp9_data_connect_request * request9)2743 ndmp_3to9_data_connect_request (
2744 ndmp3_data_connect_request *request3,
2745 ndmp9_data_connect_request *request9)
2746 {
2747 return ndmp_3to9_addr (&request3->addr, &request9->addr);
2748 }
2749
2750 int
ndmp_9to3_data_connect_request(ndmp9_data_connect_request * request9,ndmp3_data_connect_request * request3)2751 ndmp_9to3_data_connect_request (
2752 ndmp9_data_connect_request *request9,
2753 ndmp3_data_connect_request *request3)
2754 {
2755 return ndmp_9to3_addr (&request9->addr, &request3->addr);
2756 }
2757
2758
2759
2760
2761 /*
2762 * NOTIFY INTERFACES
2763 ****************************************************************
2764 */
2765
2766 /*
2767 * ndmp_notify_data_halted
2768 * just error reply
2769 */
2770
2771 int
ndmp_3to9_notify_data_halted_request(ndmp3_notify_data_halted_request * request3,ndmp9_notify_data_halted_request * request9)2772 ndmp_3to9_notify_data_halted_request (
2773 ndmp3_notify_data_halted_request *request3,
2774 ndmp9_notify_data_halted_request *request9)
2775 {
2776 int n_error = 0;
2777 int rc;
2778
2779 rc = CNVT_E_TO_9 (request3, request9, reason,
2780 ndmp_39_data_halt_reason);
2781 if (rc == NDMP_INVALID_GENERAL) {
2782 CNVT_TO_9 (request3, request9, reason);
2783 n_error++;
2784 }
2785
2786 return n_error;
2787 }
2788
2789 int
ndmp_9to3_notify_data_halted_request(ndmp9_notify_data_halted_request * request9,ndmp3_notify_data_halted_request * request3)2790 ndmp_9to3_notify_data_halted_request (
2791 ndmp9_notify_data_halted_request *request9,
2792 ndmp3_notify_data_halted_request *request3)
2793 {
2794 int n_error = 0;
2795 int rc;
2796
2797 rc = CNVT_E_FROM_9 (request3, request9, reason,
2798 ndmp_39_data_halt_reason);
2799 if (rc == NDMP_INVALID_GENERAL) {
2800 CNVT_FROM_9 (request3, request9, reason);
2801 n_error++;
2802 }
2803
2804 request3->text_reason = NDMOS_API_STRDUP("whatever");
2805
2806 return n_error;
2807 }
2808
2809
2810 /*
2811 * ndmp_notify_connected
2812 * just error reply
2813 */
2814
2815 /* NDMP3_NOTIFY_CONNECTED */
2816 struct enum_conversion ndmp_39_connect_reason[] = {
2817 { NDMP_INVALID_GENERAL, NDMP_INVALID_GENERAL, }, /* default */
2818 { NDMP3_CONNECTED, NDMP9_CONNECTED },
2819 { NDMP3_SHUTDOWN, NDMP9_SHUTDOWN },
2820 { NDMP3_REFUSED, NDMP9_REFUSED },
2821 END_ENUM_CONVERSION_TABLE
2822 };
2823
2824 int
ndmp_3to9_notify_connected_request(ndmp3_notify_connected_request * request3,ndmp9_notify_connected_request * request9)2825 ndmp_3to9_notify_connected_request (
2826 ndmp3_notify_connected_request *request3,
2827 ndmp9_notify_connected_request *request9)
2828 {
2829 int n_error = 0;
2830 int rc;
2831
2832 rc = CNVT_E_TO_9 (request3, request9, reason, ndmp_39_connect_reason);
2833 if (rc == NDMP_INVALID_GENERAL) {
2834 CNVT_TO_9 (request3, request9, reason);
2835 n_error++;
2836 }
2837
2838 CNVT_TO_9 (request3, request9, protocol_version);
2839
2840 CNVT_STRDUP_TO_9 (request3, request9, text_reason);
2841
2842 return n_error;
2843 }
2844
2845 int
ndmp_9to3_notify_connected_request(ndmp9_notify_connected_request * request9,ndmp3_notify_connected_request * request3)2846 ndmp_9to3_notify_connected_request (
2847 ndmp9_notify_connected_request *request9,
2848 ndmp3_notify_connected_request *request3)
2849 {
2850 int n_error = 0;
2851 int rc;
2852
2853 rc = CNVT_E_FROM_9(request3, request9, reason, ndmp_39_connect_reason);
2854 if (rc == NDMP_INVALID_GENERAL) {
2855 CNVT_FROM_9 (request3, request9, reason);
2856 n_error++;
2857 }
2858
2859 CNVT_FROM_9 (request3, request9, protocol_version);
2860
2861 CNVT_STRDUP_FROM_9 (request3, request9, text_reason);
2862
2863 return n_error;
2864 }
2865
2866
2867 /*
2868 * ndmp_notify_mover_halted
2869 * just error reply
2870 */
2871
2872 int
ndmp_3to9_notify_mover_halted_request(ndmp3_notify_mover_halted_request * request3,ndmp9_notify_mover_halted_request * request9)2873 ndmp_3to9_notify_mover_halted_request (
2874 ndmp3_notify_mover_halted_request *request3,
2875 ndmp9_notify_mover_halted_request *request9)
2876 {
2877 int n_error = 0;
2878 int rc;
2879
2880 rc = CNVT_E_TO_9 (request3, request9, reason,
2881 ndmp_39_mover_halt_reason);
2882 if (rc == NDMP_INVALID_GENERAL) {
2883 CNVT_TO_9 (request3, request9, reason);
2884 n_error++;
2885 }
2886
2887 return n_error;
2888 }
2889
2890 int
ndmp_9to3_notify_mover_halted_request(ndmp9_notify_mover_halted_request * request9,ndmp3_notify_mover_halted_request * request3)2891 ndmp_9to3_notify_mover_halted_request (
2892 ndmp9_notify_mover_halted_request *request9,
2893 ndmp3_notify_mover_halted_request *request3)
2894 {
2895 int n_error = 0;
2896 int rc;
2897
2898 rc = CNVT_E_FROM_9 (request3, request9, reason,
2899 ndmp_39_mover_halt_reason);
2900 if (rc == NDMP_INVALID_GENERAL) {
2901 CNVT_FROM_9 (request3, request9, reason);
2902 n_error++;
2903 }
2904
2905 request3->text_reason = NDMOS_API_STRDUP ("Whatever");
2906
2907 return n_error;
2908 }
2909
2910
2911 /*
2912 * ndmp_notify_mover_paused
2913 * just error reply
2914 */
2915
2916 int
ndmp_3to9_notify_mover_paused_request(ndmp3_notify_mover_paused_request * request3,ndmp9_notify_mover_paused_request * request9)2917 ndmp_3to9_notify_mover_paused_request (
2918 ndmp3_notify_mover_paused_request *request3,
2919 ndmp9_notify_mover_paused_request *request9)
2920 {
2921 int n_error = 0;
2922 int rc;
2923
2924 rc = CNVT_E_TO_9 (request3, request9, reason,
2925 ndmp_39_mover_pause_reason);
2926 if (rc == NDMP_INVALID_GENERAL) {
2927 CNVT_TO_9 (request3, request9, reason);
2928 n_error++;
2929 }
2930
2931 CNVT_TO_9 (request3, request9, seek_position);
2932
2933 return n_error;
2934 }
2935
2936 int
ndmp_9to3_notify_mover_paused_request(ndmp9_notify_mover_paused_request * request9,ndmp3_notify_mover_paused_request * request3)2937 ndmp_9to3_notify_mover_paused_request (
2938 ndmp9_notify_mover_paused_request *request9,
2939 ndmp3_notify_mover_paused_request *request3)
2940 {
2941 int n_error = 0;
2942 int rc;
2943
2944 rc = CNVT_E_FROM_9 (request3, request9, reason,
2945 ndmp_39_mover_pause_reason);
2946 if (rc == NDMP_INVALID_GENERAL) {
2947 CNVT_FROM_9 (request3, request9, reason);
2948 n_error++;
2949 }
2950
2951 CNVT_FROM_9 (request3, request9, seek_position);
2952
2953 return n_error;
2954 }
2955
2956
2957 /*
2958 * ndmp_notify_data_read
2959 * just error reply
2960 */
2961
2962 int
ndmp_3to9_notify_data_read_request(ndmp3_notify_data_read_request * request3,ndmp9_notify_data_read_request * request9)2963 ndmp_3to9_notify_data_read_request (
2964 ndmp3_notify_data_read_request *request3,
2965 ndmp9_notify_data_read_request *request9)
2966 {
2967 CNVT_TO_9 (request3, request9, offset);
2968 CNVT_TO_9 (request3, request9, length);
2969 return 0;
2970 }
2971
2972 int
ndmp_9to3_notify_data_read_request(ndmp9_notify_data_read_request * request9,ndmp3_notify_data_read_request * request3)2973 ndmp_9to3_notify_data_read_request (
2974 ndmp9_notify_data_read_request *request9,
2975 ndmp3_notify_data_read_request *request3)
2976 {
2977 CNVT_FROM_9 (request3, request9, offset);
2978 CNVT_FROM_9 (request3, request9, length);
2979 return 0;
2980 }
2981
2982
2983
2984
2985 /*
2986 * LOGGING INTERFACES
2987 ****************************************************************
2988 */
2989
2990 struct enum_conversion ndmp_39_recovery_status[] = {
2991 { NDMP3_UNDEFINED_ERR,
2992 NDMP9_RECOVERY_FAILED_UNDEFINED_ERROR }, /* default */
2993 { NDMP3_NO_ERR,
2994 NDMP9_RECOVERY_SUCCESSFUL },
2995 { NDMP3_PERMISSION_ERR,
2996 NDMP9_RECOVERY_FAILED_PERMISSION },
2997 { NDMP3_FILE_NOT_FOUND_ERR,
2998 NDMP9_RECOVERY_FAILED_NOT_FOUND },
2999 { NDMP3_BAD_FILE_ERR,
3000 NDMP9_RECOVERY_FAILED_NO_DIRECTORY },
3001 { NDMP3_NO_MEM_ERR,
3002 NDMP9_RECOVERY_FAILED_OUT_OF_MEMORY },
3003 { NDMP3_IO_ERR,
3004 NDMP9_RECOVERY_FAILED_IO_ERROR },
3005 { NDMP3_UNDEFINED_ERR,
3006 NDMP9_RECOVERY_FAILED_UNDEFINED_ERROR },
3007 END_ENUM_CONVERSION_TABLE
3008 };
3009
3010
3011 int
ndmp_3to9_log_file_request(ndmp3_log_file_request * request3,ndmp9_log_file_request * request9)3012 ndmp_3to9_log_file_request (
3013 ndmp3_log_file_request *request3,
3014 ndmp9_log_file_request *request9)
3015 {
3016 request9->recovery_status =
3017 convert_enum_to_9 (ndmp_39_recovery_status, request3->error);
3018 CNVT_STRDUP_TO_9 (request3, request9, name);
3019 return 0;
3020 }
3021
3022 int
ndmp_9to3_log_file_request(ndmp9_log_file_request * request9,ndmp3_log_file_request * request3)3023 ndmp_9to3_log_file_request (
3024 ndmp9_log_file_request *request9,
3025 ndmp3_log_file_request *request3)
3026 {
3027 request3->error = convert_enum_from_9 (ndmp_39_recovery_status,
3028 request9->recovery_status);
3029 CNVT_STRDUP_FROM_9 (request3, request9, name);
3030 return 0;
3031 }
3032
3033
3034 /*
3035 * ndmp_log_type
3036 */
3037
3038 struct enum_conversion ndmp_39_log_type[] = {
3039 { NDMP3_LOG_NORMAL, NDMP_INVALID_GENERAL, }, /* default */
3040 { NDMP3_LOG_NORMAL, NDMP9_LOG_NORMAL },
3041 { NDMP3_LOG_DEBUG, NDMP9_LOG_DEBUG },
3042 { NDMP3_LOG_ERROR, NDMP9_LOG_ERROR },
3043 { NDMP3_LOG_WARNING, NDMP9_LOG_WARNING },
3044 END_ENUM_CONVERSION_TABLE
3045 };
3046
3047
3048
3049 int
ndmp_3to9_log_message_request(ndmp3_log_message_request * request3,ndmp9_log_message_request * request9)3050 ndmp_3to9_log_message_request (
3051 ndmp3_log_message_request *request3,
3052 ndmp9_log_message_request *request9)
3053 {
3054 CNVT_E_TO_9 (request3, request9, log_type, ndmp_39_log_type);
3055 CNVT_TO_9 (request3, request9, message_id);
3056 CNVT_STRDUP_TO_9 (request3, request9, entry);
3057
3058 request9->associated_message_sequence.valid = NDMP9_VALIDITY_INVALID;
3059 request9->associated_message_sequence.value = NDMP9_INVALID_U_LONG;
3060
3061 return 0;
3062 }
3063
3064 int
ndmp_9to3_log_message_request(ndmp9_log_message_request * request9,ndmp3_log_message_request * request3)3065 ndmp_9to3_log_message_request (
3066 ndmp9_log_message_request *request9,
3067 ndmp3_log_message_request *request3)
3068 {
3069 CNVT_E_FROM_9 (request3, request9, log_type, ndmp_39_log_type);
3070 CNVT_FROM_9 (request3, request9, message_id);
3071 CNVT_STRDUP_TO_9 (request3, request9, entry);
3072
3073 return 0;
3074 }
3075
3076
3077
3078
3079 /*
3080 * FILE HISTORY INTERFACES
3081 ****************************************************************
3082 */
3083
3084
3085 /*
3086 * ndmp[_unix]_file_stat
3087 */
3088
3089 struct enum_conversion ndmp_39_file_type[] = {
3090 { NDMP3_FILE_OTHER, NDMP_INVALID_GENERAL, }, /* default */
3091 { NDMP3_FILE_DIR, NDMP9_FILE_DIR },
3092 { NDMP3_FILE_FIFO, NDMP9_FILE_FIFO },
3093 { NDMP3_FILE_CSPEC, NDMP9_FILE_CSPEC },
3094 { NDMP3_FILE_BSPEC, NDMP9_FILE_BSPEC },
3095 { NDMP3_FILE_REG, NDMP9_FILE_REG },
3096 { NDMP3_FILE_SLINK, NDMP9_FILE_SLINK },
3097 { NDMP3_FILE_SOCK, NDMP9_FILE_SOCK },
3098 { NDMP3_FILE_REGISTRY, NDMP9_FILE_REGISTRY },
3099 { NDMP3_FILE_OTHER, NDMP9_FILE_OTHER },
3100 END_ENUM_CONVERSION_TABLE
3101 };
3102
3103 extern int
ndmp_3to9_file_stat(ndmp3_file_stat * fstat3,ndmp9_file_stat * fstat9,ndmp9_u_quad node,ndmp9_u_quad fh_info)3104 ndmp_3to9_file_stat (
3105 ndmp3_file_stat *fstat3,
3106 ndmp9_file_stat *fstat9,
3107 ndmp9_u_quad node,
3108 ndmp9_u_quad fh_info)
3109 {
3110 CNVT_E_TO_9 (fstat3, fstat9, ftype, ndmp_39_file_type);
3111
3112 CNVT_VUL_TO_9 (fstat3, fstat9, mtime);
3113 CNVT_VUL_TO_9 (fstat3, fstat9, atime);
3114 CNVT_VUL_TO_9 (fstat3, fstat9, ctime);
3115 CNVT_VUL_TO_9x (fstat3, fstat9, owner, uid);
3116 CNVT_VUL_TO_9x (fstat3, fstat9, group, gid);
3117
3118 CNVT_VUL_TO_9x (fstat3, fstat9, fattr, mode);
3119
3120 CNVT_VUQ_TO_9 (fstat3, fstat9, size);
3121
3122 CNVT_VUL_TO_9 (fstat3, fstat9, links);
3123
3124 convert_valid_u_quad_to_9 (&node, &fstat9->node);
3125 convert_valid_u_quad_to_9 (&fh_info, &fstat9->fh_info);
3126
3127 if (fstat3->invalid & NDMP3_FILE_STAT_ATIME_INVALID)
3128 CNVT_IUL_TO_9 (fstat9, atime);
3129
3130 if (fstat3->invalid & NDMP3_FILE_STAT_CTIME_INVALID)
3131 CNVT_IUL_TO_9 (fstat9, ctime);
3132
3133 if (fstat3->invalid & NDMP3_FILE_STAT_GROUP_INVALID)
3134 CNVT_IUL_TO_9 (fstat9, gid);
3135
3136 return 0;
3137 }
3138
3139 extern int
ndmp_9to3_file_stat(ndmp9_file_stat * fstat9,ndmp3_file_stat * fstat3)3140 ndmp_9to3_file_stat (
3141 ndmp9_file_stat *fstat9,
3142 ndmp3_file_stat *fstat3)
3143 {
3144 CNVT_E_FROM_9 (fstat3, fstat9, ftype, ndmp_39_file_type);
3145
3146 fstat3->fs_type = NDMP3_FS_UNIX;
3147
3148 CNVT_VUL_FROM_9 (fstat3, fstat9, mtime);
3149 CNVT_VUL_FROM_9 (fstat3, fstat9, atime);
3150 CNVT_VUL_FROM_9 (fstat3, fstat9, ctime);
3151 CNVT_VUL_FROM_9x (fstat3, fstat9, owner, uid);
3152 CNVT_VUL_FROM_9x (fstat3, fstat9, group, gid);
3153
3154 CNVT_VUL_FROM_9x (fstat3, fstat9, fattr, mode);
3155
3156 CNVT_VUQ_FROM_9 (fstat3, fstat9, size);
3157
3158 CNVT_VUL_FROM_9 (fstat3, fstat9, links);
3159
3160 fstat3->invalid = 0;
3161
3162 if (!fstat9->atime.valid)
3163 fstat3->invalid |= NDMP3_FILE_STAT_ATIME_INVALID;
3164
3165 if (!fstat9->ctime.valid)
3166 fstat3->invalid |= NDMP3_FILE_STAT_CTIME_INVALID;
3167
3168 if (!fstat9->gid.valid)
3169 fstat3->invalid |= NDMP3_FILE_STAT_GROUP_INVALID;
3170
3171 /* fh_info ignored */
3172 /* node ignored */
3173
3174 return 0;
3175 }
3176
3177
3178 /*
3179 * ndmp_fh_add_file_request
3180 */
3181
3182 int
ndmp_3to9_fh_add_file_request(ndmp3_fh_add_file_request * request3,ndmp9_fh_add_file_request * request9)3183 ndmp_3to9_fh_add_file_request (
3184 ndmp3_fh_add_file_request *request3,
3185 ndmp9_fh_add_file_request *request9)
3186 {
3187 int n_ent = request3->files.files_len;
3188 unsigned int j;
3189 int i;
3190 ndmp9_file * table;
3191
3192 table = NDMOS_MACRO_NEWN(ndmp9_file, n_ent);
3193 if (!table)
3194 return -1;
3195
3196 NDMOS_API_BZERO (table, sizeof *table * n_ent);
3197
3198 for (i = 0; i < n_ent; i++) {
3199 ndmp3_file * ent3 = &request3->files.files_val[i];
3200 ndmp3_file_name * file_name;
3201 ndmp3_file_stat * file_stat = 0;
3202 ndmp3_file_stat _file_stat;
3203 char * filename;
3204 ndmp9_file * ent9 = &table[i];
3205
3206 filename = "no-unix-name";
3207 for (j = 0; j < ent3->names.names_len; j++) {
3208 file_name = &ent3->names.names_val[j];
3209 if (file_name->fs_type == NDMP3_FS_UNIX) {
3210 filename =
3211 file_name->ndmp3_file_name_u.unix_name;
3212 break;
3213 }
3214 }
3215 for (j = 0; j < ent3->stats.stats_len; j++) {
3216 file_stat = &ent3->stats.stats_val[j];
3217 if (file_stat->fs_type == NDMP3_FS_UNIX) {
3218 break;
3219 }
3220 }
3221 if (j >= ent3->stats.stats_len) {
3222 file_stat = &_file_stat;
3223 NDMOS_MACRO_ZEROFILL (file_stat);
3224 }
3225
3226 ent9->unix_path = NDMOS_API_STRDUP(filename);
3227 ndmp_3to9_file_stat (file_stat, &ent9->fstat,
3228 ent3->node, ent3->fh_info);
3229 }
3230
3231 request9->files.files_len = n_ent;
3232 request9->files.files_val = table;
3233
3234 return 0;
3235 }
3236
3237 int
ndmp_9to3_fh_add_file_request(ndmp9_fh_add_file_request * request9,ndmp3_fh_add_file_request * request3)3238 ndmp_9to3_fh_add_file_request (
3239 ndmp9_fh_add_file_request *request9,
3240 ndmp3_fh_add_file_request *request3)
3241 {
3242 int n_ent = request9->files.files_len;
3243 int i;
3244 ndmp3_file * table;
3245
3246 table = NDMOS_MACRO_NEWN(ndmp3_file, n_ent);
3247 if (!table)
3248 return -1;
3249
3250 NDMOS_API_BZERO (table, sizeof *table * n_ent);
3251
3252 for (i = 0; i < n_ent; i++) {
3253 ndmp9_file * ent9 = &request9->files.files_val[i];
3254 ndmp3_file * ent3 = &table[i];
3255
3256 ent3->names.names_val = NDMOS_MACRO_NEW(ndmp3_file_name);
3257 ent3->names.names_len = 1;
3258 ent3->stats.stats_val = NDMOS_MACRO_NEW(ndmp3_file_stat);
3259 ent3->stats.stats_len = 1;
3260
3261 ent3->names.names_val[0].fs_type = NDMP3_FS_UNIX;
3262 ent3->names.names_val[0].ndmp3_file_name_u.unix_name =
3263 NDMOS_API_STRDUP(ent9->unix_path);
3264
3265 ndmp_9to3_file_stat (&ent9->fstat,
3266 &ent3->stats.stats_val[0]);
3267 ent3->node = ent9->fstat.node.value;
3268 ent3->fh_info = ent9->fstat.fh_info.value;
3269 }
3270
3271 request3->files.files_len = n_ent;
3272 request3->files.files_val = table;
3273
3274 return 0;
3275 }
3276
3277
3278 /*
3279 * ndmp_fh_add_unix_dir
3280 */
3281
3282 int
ndmp_3to9_fh_add_dir_request(ndmp3_fh_add_dir_request * request3,ndmp9_fh_add_dir_request * request9)3283 ndmp_3to9_fh_add_dir_request (
3284 ndmp3_fh_add_dir_request *request3,
3285 ndmp9_fh_add_dir_request *request9)
3286 {
3287 int n_ent = request3->dirs.dirs_len;
3288 int i;
3289 unsigned int j;
3290 ndmp9_dir * table;
3291
3292 table = NDMOS_MACRO_NEWN(ndmp9_dir, n_ent);
3293 if (!table)
3294 return -1;
3295
3296 NDMOS_API_BZERO (table, sizeof *table * n_ent);
3297
3298 for (i = 0; i < n_ent; i++) {
3299 ndmp3_dir * ent3 = &request3->dirs.dirs_val[i];
3300 ndmp3_file_name * file_name;
3301 char * filename;
3302 ndmp9_dir * ent9 = &table[i];
3303
3304 filename = "no-unix-name";
3305 for (j = 0; j < ent3->names.names_len; j++) {
3306 file_name = &ent3->names.names_val[j];
3307 if (file_name->fs_type == NDMP3_FS_UNIX) {
3308 filename =
3309 file_name->ndmp3_file_name_u.unix_name;
3310 break;
3311 }
3312 }
3313
3314 ent9->unix_name = NDMOS_API_STRDUP(filename);
3315 ent9->node = ent3->node;
3316 ent9->parent = ent3->parent;
3317 }
3318
3319 request9->dirs.dirs_len = n_ent;
3320 request9->dirs.dirs_val = table;
3321
3322 return 0;
3323 }
3324
3325 int
ndmp_3to9_fh_add_dir_free_request(ndmp9_fh_add_dir_request * request9)3326 ndmp_3to9_fh_add_dir_free_request (ndmp9_fh_add_dir_request *request9)
3327 {
3328 int i;
3329
3330 if (request9) {
3331 if(request9->dirs.dirs_val) {
3332 int n_ent = request9->dirs.dirs_len;
3333
3334 for (i = 0; i < n_ent; i++) {
3335 ndmp9_dir *ent9 = &request9->dirs.dirs_val[i];
3336 if (ent9->unix_name)
3337 NDMOS_API_FREE(ent9->unix_name);
3338 ent9->unix_name = 0;
3339 }
3340
3341 NDMOS_API_FREE(request9->dirs.dirs_val);
3342 }
3343 request9->dirs.dirs_val = 0;
3344 }
3345 return 0;
3346 }
3347
3348 int
ndmp_9to3_fh_add_dir_request(ndmp9_fh_add_dir_request * request9,ndmp3_fh_add_dir_request * request3)3349 ndmp_9to3_fh_add_dir_request (
3350 ndmp9_fh_add_dir_request *request9,
3351 ndmp3_fh_add_dir_request *request3)
3352 {
3353 int n_ent = request9->dirs.dirs_len;
3354 int i;
3355 ndmp3_dir * table;
3356
3357 table = NDMOS_MACRO_NEWN(ndmp3_dir, n_ent);
3358 if (!table)
3359 return -1;
3360
3361 NDMOS_API_BZERO (table, sizeof *table * n_ent);
3362
3363 for (i = 0; i < n_ent; i++) {
3364 ndmp9_dir * ent9 = &request9->dirs.dirs_val[i];
3365 ndmp3_dir * ent3 = &table[i];
3366
3367 ent3->names.names_val = NDMOS_MACRO_NEW(ndmp3_file_name);
3368 ent3->names.names_len = 1;
3369
3370 ent3->names.names_val[0].fs_type = NDMP3_FS_UNIX;
3371 ent3->names.names_val[0].ndmp3_file_name_u.unix_name =
3372 NDMOS_API_STRDUP(ent9->unix_name);
3373
3374 ent3->node = ent9->node;
3375 ent3->parent = ent9->parent;
3376 }
3377
3378 request3->dirs.dirs_len = n_ent;
3379 request3->dirs.dirs_val = table;
3380
3381 return 0;
3382 }
3383
3384 int
ndmp_9to3_fh_add_dir_free_request(ndmp3_fh_add_dir_request * request3)3385 ndmp_9to3_fh_add_dir_free_request (ndmp3_fh_add_dir_request *request3)
3386 {
3387 int i;
3388
3389 if (request3) {
3390 if(request3->dirs.dirs_val) {
3391 int n_ent = request3->dirs.dirs_len;
3392
3393 for (i = 0; i < n_ent; i++) {
3394 ndmp3_dir *ent3 = &request3->dirs.dirs_val[i];
3395 if (ent3->names.names_val) {
3396 if (ent3->names.names_val[0].ndmp3_file_name_u.unix_name)
3397 NDMOS_API_FREE(ent3->names.names_val[0].ndmp3_file_name_u.unix_name);
3398 ent3->names.names_val[0].ndmp3_file_name_u.unix_name = 0;
3399
3400 NDMOS_API_FREE(ent3->names.names_val);
3401 }
3402 ent3->names.names_val = 0;
3403 }
3404
3405 NDMOS_API_FREE(request3->dirs.dirs_val);
3406 }
3407 request3->dirs.dirs_val = 0;
3408 }
3409
3410 return 0;
3411 }
3412
3413
3414 /*
3415 * ndmp_fh_add_node_request
3416 */
3417
3418 int
ndmp_3to9_fh_add_node_request(ndmp3_fh_add_node_request * request3,ndmp9_fh_add_node_request * request9)3419 ndmp_3to9_fh_add_node_request (
3420 ndmp3_fh_add_node_request *request3,
3421 ndmp9_fh_add_node_request *request9)
3422 {
3423 int n_ent = request3->nodes.nodes_len;
3424 int i;
3425 unsigned int j;
3426 ndmp9_node * table;
3427
3428 table = NDMOS_MACRO_NEWN(ndmp9_node, n_ent);
3429 if (!table)
3430 return -1;
3431
3432 NDMOS_API_BZERO (table, sizeof *table * n_ent);
3433
3434 for (i = 0; i < n_ent; i++) {
3435 ndmp3_node * ent3 = &request3->nodes.nodes_val[i];
3436 ndmp3_file_stat * file_stat = 0;
3437 ndmp3_file_stat _file_stat;
3438 ndmp9_node * ent9 = &table[i];
3439
3440 for (j = 0; j < ent3->stats.stats_len; j++) {
3441 file_stat = &ent3->stats.stats_val[j];
3442 if (file_stat->fs_type == NDMP3_FS_UNIX) {
3443 break;
3444 }
3445 }
3446 if (j >= ent3->stats.stats_len) {
3447 file_stat = &_file_stat;
3448 NDMOS_MACRO_ZEROFILL (file_stat);
3449 }
3450
3451 ndmp_3to9_file_stat (file_stat, &ent9->fstat,
3452 ent3->node, ent3->fh_info);
3453 }
3454
3455 request9->nodes.nodes_len = n_ent;
3456 request9->nodes.nodes_val = table;
3457
3458 return 0;
3459 }
3460
3461 int
ndmp_3to9_fh_add_node_free_request(ndmp9_fh_add_node_request * request9)3462 ndmp_3to9_fh_add_node_free_request (ndmp9_fh_add_node_request *request9)
3463 {
3464 if (request9) {
3465 if(request9->nodes.nodes_val) {
3466 NDMOS_API_FREE(request9->nodes.nodes_val);
3467 }
3468 request9->nodes.nodes_val = 0;
3469 }
3470 return 0;
3471 }
3472
3473
3474 int
ndmp_9to3_fh_add_node_request(ndmp9_fh_add_node_request * request9,ndmp3_fh_add_node_request * request3)3475 ndmp_9to3_fh_add_node_request (
3476 ndmp9_fh_add_node_request *request9,
3477 ndmp3_fh_add_node_request *request3)
3478 {
3479 int n_ent = request9->nodes.nodes_len;
3480 int i;
3481 ndmp3_node * table;
3482
3483 table = NDMOS_MACRO_NEWN(ndmp3_node, n_ent);
3484 if (!table)
3485 return -1;
3486
3487 NDMOS_API_BZERO (table, sizeof *table * n_ent);
3488
3489 for (i = 0; i < n_ent; i++) {
3490 ndmp9_node * ent9 = &request9->nodes.nodes_val[i];
3491 ndmp3_node * ent3 = &table[i];
3492
3493 ent3->stats.stats_val = NDMOS_MACRO_NEW(ndmp3_file_stat);
3494 ent3->stats.stats_len = 1;
3495
3496 ndmp_9to3_file_stat (&ent9->fstat,
3497 &ent3->stats.stats_val[0]);
3498 ent3->node = ent9->fstat.node.value;
3499 ent3->fh_info = ent9->fstat.fh_info.value;
3500 }
3501
3502 request3->nodes.nodes_len = n_ent;
3503 request3->nodes.nodes_val = table;
3504
3505 return 0;
3506 }
3507
3508 int
ndmp_9to3_fh_add_node_free_request(ndmp3_fh_add_node_request * request3)3509 ndmp_9to3_fh_add_node_free_request (ndmp3_fh_add_node_request *request3)
3510 {
3511 if (request3) {
3512 if(request3->nodes.nodes_val) {
3513 NDMOS_API_FREE(request3->nodes.nodes_val);
3514 }
3515 request3->nodes.nodes_val = 0;
3516 }
3517 return 0;
3518 }
3519
3520
3521
3522 /*
3523 * request/reply translation
3524 */
3525
3526 #define NO_ARG_REQUEST \
3527 ndmp_xtox_no_arguments, ndmp_xtox_no_arguments
3528
3529 #define JUST_ERROR_REPLY \
3530 ndmp_3to9_error, ndmp_9to3_error
3531
3532 #define NO_ARG_REQUEST_JUST_ERROR_REPLY \
3533 NO_ARG_REQUEST, JUST_ERROR_REPLY
3534
3535 #define NO_MEMUSED_REQUEST \
3536 ndmp_xtox_no_memused, ndmp_xtox_no_memused
3537
3538 #define NO_MEMUSED_REPLY \
3539 ndmp_xtox_no_memused, ndmp_xtox_no_memused
3540
3541 #define NO_MEMUSED \
3542 ndmp_xtox_no_memused, ndmp_xtox_no_memused, ndmp_xtox_no_memused, ndmp_xtox_no_memused
3543
3544
3545
3546
3547
3548 struct reqrep_xlate ndmp3_reqrep_xlate_table[] = {
3549 {
3550 NDMP3_CONNECT_OPEN, NDMP9_CONNECT_OPEN,
3551 ndmp_3to9_connect_open_request,
3552 ndmp_9to3_connect_open_request,
3553 JUST_ERROR_REPLY,
3554 NO_MEMUSED /* no memory free routines written yet */
3555 },
3556 {
3557 NDMP3_CONNECT_CLIENT_AUTH, NDMP9_CONNECT_CLIENT_AUTH,
3558 ndmp_3to9_connect_client_auth_request,
3559 ndmp_9to3_connect_client_auth_request,
3560 JUST_ERROR_REPLY,
3561 NO_MEMUSED /* no memory free routines written yet */
3562 },
3563 {
3564 NDMP3_CONNECT_CLOSE, NDMP9_CONNECT_CLOSE,
3565 NO_ARG_REQUEST_JUST_ERROR_REPLY, /* actually no reply */
3566 NO_MEMUSED /* no memory free routines written yet */
3567 },
3568 #ifdef notyet
3569 {
3570 NDMP3_CONNECT_SERVER_AUTH, NDMP9_CONNECT_SERVER_AUTH,
3571 ndmp_3to9_connect_server_auth_request,
3572 ndmp_9to3_connect_server_auth_request,
3573 ndmp_3to9_connect_server_auth_reply,
3574 ndmp_9to3_connect_server_auth_reply,
3575 NO_MEMUSED /* no memory free routines written yet */
3576 },
3577 #endif /* notyet */
3578
3579 {
3580 NDMP3_CONFIG_GET_HOST_INFO, NDMP9_CONFIG_GET_HOST_INFO,
3581 NO_ARG_REQUEST,
3582 ndmp_3to9_config_get_host_info_reply,
3583 ndmp_9to3_config_get_host_info_reply,
3584 NO_MEMUSED /* no memory free routines written yet */
3585 },
3586 {
3587 NDMP3_CONFIG_GET_CONNECTION_TYPE, NDMP9_CONFIG_GET_CONNECTION_TYPE,
3588 NO_ARG_REQUEST,
3589 ndmp_3to9_config_get_connection_type_reply,
3590 ndmp_9to3_config_get_connection_type_reply,
3591 NO_MEMUSED /* no memory free routines written yet */
3592 },
3593 {
3594 NDMP3_CONFIG_GET_AUTH_ATTR, NDMP9_CONFIG_GET_AUTH_ATTR,
3595 ndmp_3to9_config_get_auth_attr_request,
3596 ndmp_9to3_config_get_auth_attr_request,
3597 ndmp_3to9_config_get_auth_attr_reply,
3598 ndmp_9to3_config_get_auth_attr_reply,
3599 NO_MEMUSED /* no memory free routines written yet */
3600 },
3601 {
3602 NDMP3_CONFIG_GET_BUTYPE_INFO, NDMP9_CONFIG_GET_BUTYPE_INFO,
3603 NO_ARG_REQUEST,
3604 ndmp_3to9_config_get_butype_info_reply,
3605 ndmp_9to3_config_get_butype_info_reply,
3606 NO_MEMUSED /* no memory free routines written yet */
3607 },
3608 {
3609 NDMP3_CONFIG_GET_FS_INFO, NDMP9_CONFIG_GET_FS_INFO,
3610 NO_ARG_REQUEST,
3611 ndmp_3to9_config_get_fs_info_reply,
3612 ndmp_9to3_config_get_fs_info_reply,
3613 NO_MEMUSED /* no memory free routines written yet */
3614 },
3615 {
3616 NDMP3_CONFIG_GET_TAPE_INFO, NDMP9_CONFIG_GET_TAPE_INFO,
3617 NO_ARG_REQUEST,
3618 ndmp_3to9_config_get_tape_info_reply,
3619 ndmp_9to3_config_get_tape_info_reply,
3620 NO_MEMUSED /* no memory free routines written yet */
3621 },
3622 {
3623 NDMP3_CONFIG_GET_SCSI_INFO, NDMP9_CONFIG_GET_SCSI_INFO,
3624 NO_ARG_REQUEST,
3625 ndmp_3to9_config_get_scsi_info_reply,
3626 ndmp_9to3_config_get_scsi_info_reply,
3627 NO_MEMUSED /* no memory free routines written yet */
3628 },
3629 {
3630 NDMP3_CONFIG_GET_SERVER_INFO, NDMP9_CONFIG_GET_SERVER_INFO,
3631 NO_ARG_REQUEST,
3632 ndmp_3to9_config_get_server_info_reply,
3633 ndmp_9to3_config_get_server_info_reply,
3634 NO_MEMUSED /* no memory free routines written yet */
3635 },
3636
3637 {
3638 NDMP3_SCSI_OPEN, NDMP9_SCSI_OPEN,
3639 ndmp_3to9_scsi_open_request,
3640 ndmp_9to3_scsi_open_request,
3641 JUST_ERROR_REPLY,
3642 NO_MEMUSED /* no memory free routines written yet */
3643 },
3644 {
3645 NDMP3_SCSI_CLOSE, NDMP9_SCSI_CLOSE,
3646 NO_ARG_REQUEST_JUST_ERROR_REPLY,
3647 NO_MEMUSED /* no memory free routines written yet */
3648 },
3649 {
3650 NDMP3_SCSI_GET_STATE, NDMP9_SCSI_GET_STATE,
3651 NO_ARG_REQUEST,
3652 ndmp_3to9_scsi_get_state_reply,
3653 ndmp_9to3_scsi_get_state_reply,
3654 NO_MEMUSED /* no memory free routines written yet */
3655 },
3656 {
3657 NDMP3_SCSI_SET_TARGET, NDMP9_SCSI_SET_TARGET,
3658 ndmp_3to9_scsi_set_target_request,
3659 ndmp_9to3_scsi_set_target_request,
3660 JUST_ERROR_REPLY,
3661 NO_MEMUSED /* no memory free routines written yet */
3662 },
3663 {
3664 NDMP3_SCSI_RESET_DEVICE, NDMP9_SCSI_RESET_DEVICE,
3665 NO_ARG_REQUEST_JUST_ERROR_REPLY,
3666 NO_MEMUSED /* no memory free routines written yet */
3667 },
3668 {
3669 NDMP3_SCSI_RESET_BUS, NDMP9_SCSI_RESET_BUS,
3670 NO_ARG_REQUEST_JUST_ERROR_REPLY,
3671 NO_MEMUSED /* no memory free routines written yet */
3672 },
3673 {
3674 NDMP3_SCSI_EXECUTE_CDB, NDMP9_SCSI_EXECUTE_CDB,
3675 ndmp_3to9_execute_cdb_request,
3676 ndmp_9to3_execute_cdb_request,
3677 ndmp_3to9_execute_cdb_reply,
3678 ndmp_9to3_execute_cdb_reply,
3679 NO_MEMUSED /* no memory free routines written yet */
3680 },
3681
3682
3683 {
3684 NDMP3_TAPE_OPEN, NDMP9_TAPE_OPEN,
3685 ndmp_3to9_tape_open_request,
3686 ndmp_9to3_tape_open_request,
3687 JUST_ERROR_REPLY,
3688 NO_MEMUSED /* no memory free routines written yet */
3689 },
3690 {
3691 NDMP3_TAPE_CLOSE, NDMP9_TAPE_CLOSE,
3692 NO_ARG_REQUEST_JUST_ERROR_REPLY,
3693 NO_MEMUSED /* no memory free routines written yet */
3694 },
3695 {
3696 NDMP3_TAPE_GET_STATE, NDMP9_TAPE_GET_STATE,
3697 NO_ARG_REQUEST,
3698 ndmp_3to9_tape_get_state_reply,
3699 ndmp_9to3_tape_get_state_reply,
3700 NO_MEMUSED /* no memory free routines written yet */
3701 },
3702 {
3703 NDMP3_TAPE_MTIO, NDMP9_TAPE_MTIO,
3704 ndmp_3to9_tape_mtio_request,
3705 ndmp_9to3_tape_mtio_request,
3706 ndmp_3to9_tape_mtio_reply,
3707 ndmp_9to3_tape_mtio_reply,
3708 NO_MEMUSED /* no memory free routines written yet */
3709 },
3710 {
3711 NDMP3_TAPE_WRITE, NDMP9_TAPE_WRITE,
3712 ndmp_3to9_tape_write_request,
3713 ndmp_9to3_tape_write_request,
3714 ndmp_3to9_tape_write_reply,
3715 ndmp_9to3_tape_write_reply,
3716 NO_MEMUSED /* no memory free routines written yet */
3717 },
3718 {
3719 NDMP3_TAPE_READ, NDMP9_TAPE_READ,
3720 ndmp_3to9_tape_read_request,
3721 ndmp_9to3_tape_read_request,
3722 ndmp_3to9_tape_read_reply,
3723 ndmp_9to3_tape_read_reply,
3724 NO_MEMUSED /* no memory free routines written yet */
3725 },
3726 {
3727 NDMP3_TAPE_EXECUTE_CDB, NDMP9_TAPE_EXECUTE_CDB,
3728 ndmp_3to9_execute_cdb_request,
3729 ndmp_9to3_execute_cdb_request,
3730 ndmp_3to9_execute_cdb_reply,
3731 ndmp_9to3_execute_cdb_reply,
3732 NO_MEMUSED /* no memory free routines written yet */
3733 },
3734
3735 {
3736 NDMP3_DATA_GET_STATE, NDMP9_DATA_GET_STATE,
3737 NO_ARG_REQUEST,
3738 ndmp_3to9_data_get_state_reply,
3739 ndmp_9to3_data_get_state_reply,
3740 NO_MEMUSED /* no memory free routines written yet */
3741 },
3742 {
3743 NDMP3_DATA_START_BACKUP, NDMP9_DATA_START_BACKUP,
3744 ndmp_3to9_data_start_backup_request,
3745 ndmp_9to3_data_start_backup_request,
3746 JUST_ERROR_REPLY,
3747 NO_MEMUSED /* no memory free routines written yet */
3748 },
3749 {
3750 NDMP3_DATA_START_RECOVER, NDMP9_DATA_START_RECOVER,
3751 ndmp_3to9_data_start_recover_request,
3752 ndmp_9to3_data_start_recover_request,
3753 JUST_ERROR_REPLY,
3754 NO_MEMUSED /* no memory free routines written yet */
3755 },
3756 {
3757 NDMP3_DATA_ABORT, NDMP9_DATA_ABORT,
3758 NO_ARG_REQUEST_JUST_ERROR_REPLY,
3759 NO_MEMUSED /* no memory free routines written yet */
3760 },
3761 {
3762 NDMP3_DATA_GET_ENV, NDMP9_DATA_GET_ENV,
3763 NO_ARG_REQUEST,
3764 ndmp_3to9_data_get_env_reply,
3765 ndmp_9to3_data_get_env_reply,
3766 NO_MEMUSED /* no memory free routines written yet */
3767 },
3768 {
3769 NDMP3_DATA_STOP, NDMP9_DATA_STOP,
3770 NO_ARG_REQUEST_JUST_ERROR_REPLY,
3771 NO_MEMUSED /* no memory free routines written yet */
3772 },
3773 {
3774 NDMP3_DATA_LISTEN, NDMP9_DATA_LISTEN,
3775 ndmp_3to9_data_listen_request,
3776 ndmp_9to3_data_listen_request,
3777 ndmp_3to9_data_listen_reply,
3778 ndmp_9to3_data_listen_reply,
3779 NO_MEMUSED /* no memory free routines written yet */
3780 },
3781 {
3782 NDMP3_DATA_CONNECT, NDMP9_DATA_CONNECT,
3783 ndmp_3to9_data_connect_request,
3784 ndmp_9to3_data_connect_request,
3785 JUST_ERROR_REPLY,
3786 NO_MEMUSED /* no memory free routines written yet */
3787 },
3788 {
3789 NDMP3_DATA_START_RECOVER_FILEHIST, NDMP9_DATA_START_RECOVER_FILEHIST,
3790 ndmp_3to9_data_start_recover_request,
3791 ndmp_9to3_data_start_recover_request,
3792 JUST_ERROR_REPLY,
3793 NO_MEMUSED /* no memory free routines written yet */
3794 },
3795
3796 {
3797 NDMP3_NOTIFY_DATA_HALTED, NDMP9_NOTIFY_DATA_HALTED,
3798 ndmp_3to9_notify_data_halted_request,
3799 ndmp_9to3_notify_data_halted_request,
3800 JUST_ERROR_REPLY, /* no reply actually */
3801 NO_MEMUSED /* no memory free routines written yet */
3802 },
3803 {
3804 NDMP3_NOTIFY_CONNECTED, NDMP9_NOTIFY_CONNECTED,
3805 ndmp_3to9_notify_connected_request,
3806 ndmp_9to3_notify_connected_request,
3807 JUST_ERROR_REPLY, /* no reply actually */
3808 NO_MEMUSED /* no memory free routines written yet */
3809 },
3810 {
3811 NDMP3_NOTIFY_MOVER_HALTED, NDMP9_NOTIFY_MOVER_HALTED,
3812 ndmp_3to9_notify_mover_halted_request,
3813 ndmp_9to3_notify_mover_halted_request,
3814 JUST_ERROR_REPLY, /* no reply actually */
3815 NO_MEMUSED /* no memory free routines written yet */
3816 },
3817 {
3818 NDMP3_NOTIFY_MOVER_PAUSED, NDMP9_NOTIFY_MOVER_PAUSED,
3819 ndmp_3to9_notify_mover_paused_request,
3820 ndmp_9to3_notify_mover_paused_request,
3821 JUST_ERROR_REPLY, /* no reply actually */
3822 NO_MEMUSED /* no memory free routines written yet */
3823 },
3824 {
3825 NDMP3_NOTIFY_DATA_READ, NDMP9_NOTIFY_DATA_READ,
3826 ndmp_3to9_notify_data_read_request,
3827 ndmp_9to3_notify_data_read_request,
3828 JUST_ERROR_REPLY, /* no reply actually */
3829 NO_MEMUSED /* no memory free routines written yet */
3830 },
3831
3832 {
3833 NDMP3_LOG_FILE, NDMP9_LOG_FILE,
3834 ndmp_3to9_log_file_request,
3835 ndmp_9to3_log_file_request,
3836 JUST_ERROR_REPLY, /* no reply actually */
3837 NO_MEMUSED /* no memory free routines written yet */
3838 },
3839 {
3840 NDMP3_LOG_MESSAGE, NDMP9_LOG_MESSAGE,
3841 ndmp_3to9_log_message_request,
3842 ndmp_9to3_log_message_request,
3843 JUST_ERROR_REPLY, /* no reply actually */
3844 NO_MEMUSED /* no memory free routines written yet */
3845 },
3846
3847 {
3848 NDMP3_FH_ADD_FILE, NDMP9_FH_ADD_FILE,
3849 ndmp_3to9_fh_add_file_request,
3850 ndmp_9to3_fh_add_file_request,
3851 JUST_ERROR_REPLY, /* no reply actually */
3852 NO_MEMUSED /* no memory free routines written yet */
3853 },
3854 {
3855 NDMP3_FH_ADD_DIR, NDMP9_FH_ADD_DIR,
3856 ndmp_3to9_fh_add_dir_request,
3857 ndmp_9to3_fh_add_dir_request,
3858 JUST_ERROR_REPLY, /* no reply actually */
3859 ndmp_3to9_fh_add_dir_free_request,
3860 ndmp_9to3_fh_add_dir_free_request,
3861 NO_MEMUSED_REPLY
3862 },
3863 {
3864 NDMP3_FH_ADD_NODE, NDMP9_FH_ADD_NODE,
3865 ndmp_3to9_fh_add_node_request,
3866 ndmp_9to3_fh_add_node_request,
3867 JUST_ERROR_REPLY, /* no reply actually */
3868 ndmp_3to9_fh_add_node_free_request,
3869 ndmp_9to3_fh_add_node_free_request,
3870 NO_MEMUSED_REPLY
3871 },
3872
3873 {
3874 NDMP3_MOVER_GET_STATE, NDMP9_MOVER_GET_STATE,
3875 NO_ARG_REQUEST,
3876 ndmp_3to9_mover_get_state_reply,
3877 ndmp_9to3_mover_get_state_reply,
3878 NO_MEMUSED /* no memory free routines written yet */
3879 },
3880 {
3881 NDMP3_MOVER_LISTEN, NDMP9_MOVER_LISTEN,
3882 ndmp_3to9_mover_listen_request,
3883 ndmp_9to3_mover_listen_request,
3884 ndmp_3to9_mover_listen_reply,
3885 ndmp_9to3_mover_listen_reply,
3886 NO_MEMUSED /* no memory free routines written yet */
3887 },
3888 {
3889 NDMP3_MOVER_CONNECT, NDMP9_MOVER_CONNECT,
3890 ndmp_3to9_mover_connect_request,
3891 ndmp_9to3_mover_connect_request,
3892 JUST_ERROR_REPLY,
3893 NO_MEMUSED /* no memory free routines written yet */
3894 },
3895 {
3896 NDMP3_MOVER_CONTINUE, NDMP9_MOVER_CONTINUE,
3897 NO_ARG_REQUEST_JUST_ERROR_REPLY,
3898 NO_MEMUSED /* no memory free routines written yet */
3899 },
3900 {
3901 NDMP3_MOVER_ABORT, NDMP9_MOVER_ABORT,
3902 NO_ARG_REQUEST_JUST_ERROR_REPLY,
3903 NO_MEMUSED /* no memory free routines written yet */
3904 },
3905 {
3906 NDMP3_MOVER_STOP, NDMP9_MOVER_STOP,
3907 NO_ARG_REQUEST_JUST_ERROR_REPLY,
3908 NO_MEMUSED /* no memory free routines written yet */
3909 },
3910 {
3911 NDMP3_MOVER_SET_WINDOW, NDMP9_MOVER_SET_WINDOW,
3912 ndmp_3to9_mover_set_window_request,
3913 ndmp_9to3_mover_set_window_request,
3914 JUST_ERROR_REPLY,
3915 NO_MEMUSED /* no memory free routines written yet */
3916 },
3917 {
3918 NDMP3_MOVER_READ, NDMP9_MOVER_READ,
3919 ndmp_3to9_mover_read_request,
3920 ndmp_9to3_mover_read_request,
3921 JUST_ERROR_REPLY,
3922 NO_MEMUSED /* no memory free routines written yet */
3923 },
3924 {
3925 NDMP3_MOVER_CLOSE, NDMP9_MOVER_CLOSE,
3926 NO_ARG_REQUEST_JUST_ERROR_REPLY,
3927 NO_MEMUSED /* no memory free routines written yet */
3928 },
3929 {
3930 NDMP3_MOVER_SET_RECORD_SIZE, NDMP9_MOVER_SET_RECORD_SIZE,
3931 ndmp_3to9_mover_set_record_size_request,
3932 ndmp_9to3_mover_set_record_size_request,
3933 JUST_ERROR_REPLY,
3934 NO_MEMUSED /* no memory free routines written yet */
3935 },
3936 /* ndmp_mover_connnect TBD */
3937
3938 { 0 },
3939 };
3940
3941
3942 #endif /* !NDMOS_OPTION_NO_NDMP3 */
3943