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