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_NDMP2
45
46
47 /*
48 * Pervasive Types
49 ****************************************************************
50 */
51
52 /*
53 * ndmp_error
54 */
55
56 struct enum_conversion ndmp_29_error[] = {
57 {NDMP2_UNDEFINED_ERR, NDMP9_UNDEFINED_ERR}, /* default */
58 {NDMP2_NO_ERR, NDMP9_NO_ERR},
59 {NDMP2_NOT_SUPPORTED_ERR, NDMP9_NOT_SUPPORTED_ERR},
60 {NDMP2_DEVICE_BUSY_ERR, NDMP9_DEVICE_BUSY_ERR},
61 {NDMP2_DEVICE_OPENED_ERR, NDMP9_DEVICE_OPENED_ERR},
62 {NDMP2_NOT_AUTHORIZED_ERR, NDMP9_NOT_AUTHORIZED_ERR},
63 {NDMP2_PERMISSION_ERR, NDMP9_PERMISSION_ERR},
64 {NDMP2_DEV_NOT_OPEN_ERR, NDMP9_DEV_NOT_OPEN_ERR},
65 {NDMP2_IO_ERR, NDMP9_IO_ERR},
66 {NDMP2_TIMEOUT_ERR, NDMP9_TIMEOUT_ERR},
67 {NDMP2_ILLEGAL_ARGS_ERR, NDMP9_ILLEGAL_ARGS_ERR},
68 {NDMP2_NO_TAPE_LOADED_ERR, NDMP9_NO_TAPE_LOADED_ERR},
69 {NDMP2_WRITE_PROTECT_ERR, NDMP9_WRITE_PROTECT_ERR},
70 {NDMP2_EOF_ERR, NDMP9_EOF_ERR},
71 {NDMP2_EOM_ERR, NDMP9_EOM_ERR},
72 {NDMP2_FILE_NOT_FOUND_ERR, NDMP9_FILE_NOT_FOUND_ERR},
73 {NDMP2_BAD_FILE_ERR, NDMP9_BAD_FILE_ERR},
74 {NDMP2_NO_DEVICE_ERR, NDMP9_NO_DEVICE_ERR},
75 {NDMP2_NO_BUS_ERR, NDMP9_NO_BUS_ERR},
76 {NDMP2_XDR_DECODE_ERR, NDMP9_XDR_DECODE_ERR},
77 {NDMP2_ILLEGAL_STATE_ERR, NDMP9_ILLEGAL_STATE_ERR},
78 {NDMP2_UNDEFINED_ERR, NDMP9_UNDEFINED_ERR},
79 {NDMP2_XDR_ENCODE_ERR, NDMP9_XDR_ENCODE_ERR},
80 {NDMP2_NO_MEM_ERR, NDMP9_NO_MEM_ERR},
81 END_ENUM_CONVERSION_TABLE};
82
83
ndmp_2to9_error(ndmp2_error * error2,ndmp9_error * error9)84 int ndmp_2to9_error(ndmp2_error* error2, ndmp9_error* error9)
85 {
86 *error9 = convert_enum_to_9(ndmp_29_error, *error2);
87 return 0;
88 }
89
ndmp_9to2_error(ndmp9_error * error9,ndmp2_error * error2)90 int ndmp_9to2_error(ndmp9_error* error9, ndmp2_error* error2)
91 {
92 *error2 = convert_enum_from_9(ndmp_29_error, *error9);
93 return 0;
94 }
95
96
97 /*
98 * ndmp_pval
99 ****************************************************************
100 */
101
ndmp_2to9_pval(ndmp2_pval * pval2,ndmp9_pval * pval9)102 int ndmp_2to9_pval(ndmp2_pval* pval2, ndmp9_pval* pval9)
103 {
104 CNVT_STRDUP_TO_9(pval2, pval9, name);
105 CNVT_STRDUP_TO_9(pval2, pval9, value);
106
107 return 0;
108 }
109
ndmp_9to2_pval(ndmp9_pval * pval9,ndmp2_pval * pval2)110 int ndmp_9to2_pval(ndmp9_pval* pval9, ndmp2_pval* pval2)
111 {
112 CNVT_STRDUP_FROM_9(pval2, pval9, name);
113 CNVT_STRDUP_FROM_9(pval2, pval9, value);
114
115 return 0;
116 }
117
ndmp_2to9_pval_vec(ndmp2_pval * pval2,ndmp9_pval * pval9,unsigned n_pval)118 int ndmp_2to9_pval_vec(ndmp2_pval* pval2, ndmp9_pval* pval9, unsigned n_pval)
119 {
120 unsigned int i;
121
122 for (i = 0; i < n_pval; i++) ndmp_2to9_pval(&pval2[i], &pval9[i]);
123
124 return 0;
125 }
126
ndmp_9to2_pval_vec(ndmp9_pval * pval9,ndmp2_pval * pval2,unsigned n_pval)127 int ndmp_9to2_pval_vec(ndmp9_pval* pval9, ndmp2_pval* pval2, unsigned n_pval)
128 {
129 unsigned int i;
130
131 for (i = 0; i < n_pval; i++) ndmp_9to2_pval(&pval9[i], &pval2[i]);
132
133 return 0;
134 }
135
ndmp_2to9_pval_vec_dup(ndmp2_pval * pval2,ndmp9_pval ** pval9_p,unsigned n_pval)136 int ndmp_2to9_pval_vec_dup(ndmp2_pval* pval2,
137 ndmp9_pval** pval9_p,
138 unsigned n_pval)
139 {
140 *pval9_p = NDMOS_MACRO_NEWN(ndmp9_pval, n_pval);
141 if (!*pval9_p) return -1;
142
143 return ndmp_2to9_pval_vec(pval2, *pval9_p, n_pval);
144 }
145
ndmp_9to2_pval_vec_dup(ndmp9_pval * pval9,ndmp2_pval ** pval2_p,unsigned n_pval)146 int ndmp_9to2_pval_vec_dup(ndmp9_pval* pval9,
147 ndmp2_pval** pval2_p,
148 unsigned n_pval)
149 {
150 *pval2_p = NDMOS_MACRO_NEWN(ndmp2_pval, n_pval);
151 if (!*pval2_p) return -1;
152
153 return ndmp_9to2_pval_vec(pval9, *pval2_p, n_pval);
154 }
155
156
157 /*
158 * ndmp[_mover]_addr
159 */
160
161 struct enum_conversion ndmp_29_mover_addr_type[] = {
162 {NDMP_INVALID_GENERAL, NDMP_INVALID_GENERAL}, /* default */
163 {NDMP2_ADDR_LOCAL, NDMP9_ADDR_LOCAL},
164 {NDMP2_ADDR_TCP, NDMP9_ADDR_TCP},
165 END_ENUM_CONVERSION_TABLE};
166
167
ndmp_2to9_mover_addr(ndmp2_mover_addr * addr2,ndmp9_addr * addr9)168 int ndmp_2to9_mover_addr(ndmp2_mover_addr* addr2, ndmp9_addr* addr9)
169 {
170 switch (addr2->addr_type) {
171 case NDMP2_ADDR_LOCAL:
172 addr9->addr_type = NDMP9_ADDR_LOCAL;
173 break;
174
175 case NDMP2_ADDR_TCP:
176 addr9->addr_type = NDMP9_ADDR_TCP;
177 addr9->ndmp9_addr_u.tcp_addr.ip_addr =
178 addr2->ndmp2_mover_addr_u.addr.ip_addr;
179 addr9->ndmp9_addr_u.tcp_addr.port = addr2->ndmp2_mover_addr_u.addr.port;
180 break;
181
182 default:
183 NDMOS_MACRO_ZEROFILL(addr9);
184 addr9->addr_type = -1;
185 return -1;
186 }
187
188 return 0;
189 }
190
ndmp_9to2_mover_addr(ndmp9_addr * addr9,ndmp2_mover_addr * addr2)191 int ndmp_9to2_mover_addr(ndmp9_addr* addr9, ndmp2_mover_addr* addr2)
192 {
193 switch (addr9->addr_type) {
194 case NDMP9_ADDR_LOCAL:
195 addr2->addr_type = NDMP2_ADDR_LOCAL;
196 break;
197
198 case NDMP9_ADDR_TCP:
199 addr2->addr_type = NDMP2_ADDR_TCP;
200 addr2->ndmp2_mover_addr_u.addr.ip_addr =
201 addr9->ndmp9_addr_u.tcp_addr.ip_addr;
202 addr2->ndmp2_mover_addr_u.addr.port = addr9->ndmp9_addr_u.tcp_addr.port;
203 break;
204
205 default:
206 NDMOS_MACRO_ZEROFILL(addr2);
207 addr2->addr_type = -1;
208 return -1;
209 }
210
211 return 0;
212 }
213
214
215 /*
216 * CONNECT INTERFACES
217 ****************************************************************
218 */
219
220 struct enum_conversion ndmp_29_auth_type[] = {
221 {NDMP_INVALID_GENERAL, NDMP_INVALID_GENERAL}, /* default */
222 {NDMP2_AUTH_NONE, NDMP9_AUTH_NONE},
223 {NDMP2_AUTH_TEXT, NDMP9_AUTH_TEXT},
224 {NDMP2_AUTH_MD5, NDMP9_AUTH_MD5},
225 END_ENUM_CONVERSION_TABLE};
226
ndmp_2to9_auth_data(ndmp2_auth_data * auth_data2,ndmp9_auth_data * auth_data9)227 int ndmp_2to9_auth_data(ndmp2_auth_data* auth_data2,
228 ndmp9_auth_data* auth_data9)
229 {
230 int n_error = 0;
231 int rc;
232 ndmp2_auth_text* text2;
233 ndmp9_auth_text* text9;
234 ndmp2_auth_md5* md52;
235 ndmp9_auth_md5* md59;
236
237 switch (auth_data2->auth_type) {
238 case NDMP2_AUTH_NONE:
239 auth_data9->auth_type = NDMP9_AUTH_NONE;
240 break;
241
242 case NDMP2_AUTH_TEXT:
243 auth_data9->auth_type = NDMP9_AUTH_TEXT;
244 text2 = &auth_data2->ndmp2_auth_data_u.auth_text;
245 text9 = &auth_data9->ndmp9_auth_data_u.auth_text;
246 rc = CNVT_STRDUP_TO_9(text2, text9, auth_id);
247 if (rc) { return rc; /* no mem */ }
248 rc = CNVT_STRDUP_TO_9(text2, text9, auth_password);
249 if (rc) {
250 NDMOS_API_FREE(text9->auth_id);
251 text9->auth_id = 0;
252 return rc; /* no mem */
253 }
254 break;
255
256 case NDMP2_AUTH_MD5:
257 auth_data9->auth_type = NDMP9_AUTH_MD5;
258 md52 = &auth_data2->ndmp2_auth_data_u.auth_md5;
259 md59 = &auth_data9->ndmp9_auth_data_u.auth_md5;
260 rc = CNVT_STRDUP_TO_9(md52, md59, auth_id);
261 if (rc) { return rc; /* no mem */ }
262 NDMOS_API_BCOPY(md52->auth_digest, md59->auth_digest, 16);
263 break;
264
265 default:
266 auth_data9->auth_type = auth_data2->auth_type;
267 NDMOS_MACRO_ZEROFILL(&auth_data9->ndmp9_auth_data_u);
268 n_error++;
269 break;
270 }
271
272 return n_error;
273 }
274
ndmp_9to2_auth_data(ndmp9_auth_data * auth_data9,ndmp2_auth_data * auth_data2)275 int ndmp_9to2_auth_data(ndmp9_auth_data* auth_data9,
276 ndmp2_auth_data* auth_data2)
277 {
278 int n_error = 0;
279 int rc;
280 ndmp9_auth_text* text9;
281 ndmp2_auth_text* text2;
282 ndmp9_auth_md5* md59;
283 ndmp2_auth_md5* md52;
284
285 switch (auth_data9->auth_type) {
286 case NDMP9_AUTH_NONE:
287 auth_data2->auth_type = NDMP2_AUTH_NONE;
288 break;
289
290 case NDMP9_AUTH_TEXT:
291 auth_data2->auth_type = NDMP2_AUTH_TEXT;
292 text9 = &auth_data9->ndmp9_auth_data_u.auth_text;
293 text2 = &auth_data2->ndmp2_auth_data_u.auth_text;
294 rc = CNVT_STRDUP_FROM_9(text2, text9, auth_id);
295 if (rc) { return rc; /* no mem */ }
296 rc = CNVT_STRDUP_FROM_9(text2, text9, auth_password);
297 if (rc) {
298 NDMOS_API_FREE(text9->auth_id);
299 text2->auth_id = 0;
300 return rc; /* no mem */
301 }
302 break;
303
304 case NDMP9_AUTH_MD5:
305 auth_data2->auth_type = NDMP2_AUTH_MD5;
306 md59 = &auth_data9->ndmp9_auth_data_u.auth_md5;
307 md52 = &auth_data2->ndmp2_auth_data_u.auth_md5;
308 rc = CNVT_STRDUP_FROM_9(md52, md59, auth_id);
309 if (rc) { return rc; /* no mem */ }
310 NDMOS_API_BCOPY(md59->auth_digest, md52->auth_digest, 16);
311 break;
312
313 default:
314 auth_data2->auth_type = auth_data9->auth_type;
315 NDMOS_MACRO_ZEROFILL(&auth_data2->ndmp2_auth_data_u);
316 n_error++;
317 break;
318 }
319
320 return n_error;
321 }
322
ndmp_2to9_auth_attr(ndmp2_auth_attr * auth_attr2,ndmp9_auth_attr * auth_attr9)323 int ndmp_2to9_auth_attr(ndmp2_auth_attr* auth_attr2,
324 ndmp9_auth_attr* auth_attr9)
325 {
326 int n_error = 0;
327
328 switch (auth_attr2->auth_type) {
329 case NDMP2_AUTH_NONE:
330 auth_attr9->auth_type = NDMP9_AUTH_NONE;
331 break;
332
333 case NDMP2_AUTH_TEXT:
334 auth_attr9->auth_type = NDMP9_AUTH_TEXT;
335 break;
336
337 case NDMP2_AUTH_MD5:
338 auth_attr9->auth_type = NDMP9_AUTH_MD5;
339 NDMOS_API_BCOPY(auth_attr2->ndmp2_auth_attr_u.challenge,
340 auth_attr9->ndmp9_auth_attr_u.challenge, 64);
341 break;
342
343 default:
344 auth_attr9->auth_type = auth_attr2->auth_type;
345 NDMOS_MACRO_ZEROFILL(&auth_attr9->ndmp9_auth_attr_u);
346 n_error++;
347 break;
348 }
349
350 return n_error;
351 }
352
ndmp_9to2_auth_attr(ndmp9_auth_attr * auth_attr9,ndmp2_auth_attr * auth_attr2)353 int ndmp_9to2_auth_attr(ndmp9_auth_attr* auth_attr9,
354 ndmp2_auth_attr* auth_attr2)
355 {
356 int n_error = 0;
357
358 switch (auth_attr9->auth_type) {
359 case NDMP9_AUTH_NONE:
360 auth_attr2->auth_type = NDMP2_AUTH_NONE;
361 break;
362
363 case NDMP9_AUTH_TEXT:
364 auth_attr2->auth_type = NDMP2_AUTH_TEXT;
365 break;
366
367 case NDMP9_AUTH_MD5:
368 auth_attr2->auth_type = NDMP2_AUTH_MD5;
369 NDMOS_API_BCOPY(auth_attr9->ndmp9_auth_attr_u.challenge,
370 auth_attr2->ndmp2_auth_attr_u.challenge, 64);
371 break;
372
373 default:
374 auth_attr2->auth_type = auth_attr9->auth_type;
375 NDMOS_MACRO_ZEROFILL(&auth_attr2->ndmp2_auth_attr_u);
376 n_error++;
377 break;
378 }
379
380 return n_error;
381 }
382
383
384 /*
385 * ndmp_connect_open
386 * just error reply
387 */
388
ndmp_2to9_connect_open_request(ndmp2_connect_open_request * request2,ndmp9_connect_open_request * request9)389 int ndmp_2to9_connect_open_request(ndmp2_connect_open_request* request2,
390 ndmp9_connect_open_request* request9)
391 {
392 CNVT_TO_9(request2, request9, protocol_version);
393 return 0;
394 }
395
ndmp_9to2_connect_open_request(ndmp9_connect_open_request * request9,ndmp2_connect_open_request * request2)396 int ndmp_9to2_connect_open_request(ndmp9_connect_open_request* request9,
397 ndmp2_connect_open_request* request2)
398 {
399 CNVT_FROM_9(request2, request9, protocol_version);
400 return 0;
401 }
402
403
404 /*
405 * ndmp_connect_client_auth
406 * just error reply
407 */
408
409
ndmp_2to9_connect_client_auth_request(ndmp2_connect_client_auth_request * request2,ndmp9_connect_client_auth_request * request9)410 int ndmp_2to9_connect_client_auth_request(
411 ndmp2_connect_client_auth_request* request2,
412 ndmp9_connect_client_auth_request* request9)
413 {
414 int rc;
415
416 rc = ndmp_2to9_auth_data(&request2->auth_data, &request9->auth_data);
417
418 return rc;
419 }
420
ndmp_9to2_connect_client_auth_request(ndmp9_connect_client_auth_request * request9,ndmp2_connect_client_auth_request * request2)421 int ndmp_9to2_connect_client_auth_request(
422 ndmp9_connect_client_auth_request* request9,
423 ndmp2_connect_client_auth_request* request2)
424 {
425 int rc;
426
427 rc = ndmp_9to2_auth_data(&request9->auth_data, &request2->auth_data);
428
429 return rc;
430 }
431
432
433 /*
434 * ndmp_connect_close
435 * no arg request, **NO REPLY**
436 */
437
438 /*
439 * ndmp_connect_server_auth
440 */
441
442 /* TBD */
ndmp_2to9_connect_server_auth_request(ndmp2_connect_server_auth_request * request2,ndmp9_connect_server_auth_request * request9)443 int ndmp_2to9_connect_server_auth_request(
444 ndmp2_connect_server_auth_request* request2,
445 ndmp9_connect_server_auth_request* request9)
446 {
447 return -1;
448 }
449
ndmp_9to2_connect_server_auth_request(ndmp9_connect_server_auth_request * request9,ndmp2_connect_server_auth_request * request2)450 int ndmp_9to2_connect_server_auth_request(
451 ndmp9_connect_server_auth_request* request9,
452 ndmp2_connect_server_auth_request* request2)
453 {
454 return -1;
455 }
456
457
458 /*
459 * CONFIG INTERFACES
460 ****************************************************************
461 */
462
463 /*
464 * ndmp_config_get_host_info
465 * no args request
466 */
467
ndmp_2to9_config_get_host_info_reply(ndmp2_config_get_host_info_reply * reply2,ndmp9_config_get_host_info_reply * reply9)468 int ndmp_2to9_config_get_host_info_reply(
469 ndmp2_config_get_host_info_reply* reply2,
470 ndmp9_config_get_host_info_reply* reply9)
471 {
472 unsigned int i, n_error = 0;
473
474 CNVT_E_TO_9(reply2, reply9, error, ndmp_29_error);
475 CNVT_STRDUP_TO_9x(reply2, reply9, hostname, config_info.hostname);
476 CNVT_STRDUP_TO_9x(reply2, reply9, os_type, config_info.os_type);
477 CNVT_STRDUP_TO_9x(reply2, reply9, os_vers, config_info.os_vers);
478 CNVT_STRDUP_TO_9x(reply2, reply9, hostid, config_info.hostid);
479
480 reply9->config_info.authtypes = 0;
481 for (i = 0; i < reply2->auth_type.auth_type_len; i++) {
482 switch (reply2->auth_type.auth_type_val[i]) {
483 case NDMP2_AUTH_NONE:
484 reply9->config_info.authtypes |= NDMP9_CONFIG_AUTHTYPE_NONE;
485 break;
486
487 case NDMP2_AUTH_TEXT:
488 reply9->config_info.authtypes |= NDMP9_CONFIG_AUTHTYPE_TEXT;
489 break;
490
491 case NDMP2_AUTH_MD5:
492 reply9->config_info.authtypes |= NDMP9_CONFIG_AUTHTYPE_MD5;
493 break;
494
495 default:
496 n_error++;
497 /* ignore */
498 break;
499 }
500 }
501
502 return n_error;
503 }
504
ndmp_9to2_config_get_host_info_reply(ndmp9_config_get_host_info_reply * reply9,ndmp2_config_get_host_info_reply * reply2)505 int ndmp_9to2_config_get_host_info_reply(
506 ndmp9_config_get_host_info_reply* reply9,
507 ndmp2_config_get_host_info_reply* reply2)
508 {
509 int i = 0;
510
511 CNVT_E_FROM_9(reply2, reply9, error, ndmp_29_error);
512 CNVT_STRDUP_FROM_9x(reply2, reply9, hostname, config_info.hostname);
513 CNVT_STRDUP_FROM_9x(reply2, reply9, os_type, config_info.os_type);
514 CNVT_STRDUP_FROM_9x(reply2, reply9, os_vers, config_info.os_vers);
515 CNVT_STRDUP_FROM_9x(reply2, reply9, hostid, config_info.hostid);
516
517 reply2->auth_type.auth_type_val = NDMOS_MACRO_NEWN(ndmp2_auth_type, 3);
518 if (!reply2->auth_type.auth_type_val) { return -1; }
519
520 i = 0;
521 if (reply9->config_info.authtypes & NDMP9_CONFIG_AUTHTYPE_NONE) {
522 reply2->auth_type.auth_type_val[i++] = NDMP2_AUTH_NONE;
523 }
524 if (reply9->config_info.authtypes & NDMP9_CONFIG_AUTHTYPE_TEXT) {
525 reply2->auth_type.auth_type_val[i++] = NDMP2_AUTH_TEXT;
526 }
527 if (reply9->config_info.authtypes & NDMP9_CONFIG_AUTHTYPE_MD5) {
528 reply2->auth_type.auth_type_val[i++] = NDMP2_AUTH_MD5;
529 }
530 reply2->auth_type.auth_type_len = i;
531
532 return 0;
533 }
534
535
536 /*
537 * ndmp_config_get_butype_attr
538 * ndmp2_config_get_butype_attr handled
539 * as version specific dispatch function
540 * in ndma_comm_dispatch.c
541 */
542
543
544 /*
545 * ndmp_config_get_mover_type
546 * no args request
547 */
548
ndmp_2to9_config_get_mover_type_reply(ndmp2_config_get_mover_type_reply * reply2,ndmp9_config_get_connection_type_reply * reply9)549 int ndmp_2to9_config_get_mover_type_reply(
550 ndmp2_config_get_mover_type_reply* reply2,
551 ndmp9_config_get_connection_type_reply* reply9)
552 {
553 int n_error = 0;
554 unsigned int i;
555
556 CNVT_E_TO_9(reply2, reply9, error, ndmp_29_error);
557 for (i = 0; i < reply2->methods.methods_len; i++) {
558 switch (reply2->methods.methods_val[i]) {
559 case NDMP2_ADDR_LOCAL:
560 reply9->config_info.conntypes |= NDMP9_CONFIG_CONNTYPE_LOCAL;
561 break;
562
563 case NDMP2_ADDR_TCP:
564 reply9->config_info.conntypes |= NDMP9_CONFIG_CONNTYPE_TCP;
565 break;
566
567 default:
568 n_error++;
569 /* ignore */
570 break;
571 }
572 }
573
574 return n_error;
575 }
576
ndmp_9to2_config_get_mover_type_reply(ndmp9_config_get_connection_type_reply * reply9,ndmp2_config_get_mover_type_reply * reply2)577 int ndmp_9to2_config_get_mover_type_reply(
578 ndmp9_config_get_connection_type_reply* reply9,
579 ndmp2_config_get_mover_type_reply* reply2)
580 {
581 int i = 0;
582
583 CNVT_E_FROM_9(reply2, reply9, error, ndmp_29_error);
584
585 reply2->methods.methods_val = NDMOS_MACRO_NEWN(ndmp2_mover_addr_type, 3);
586 if (!reply2->methods.methods_val) { return -1; /* no mem */ }
587
588 i = 0;
589 if (reply9->config_info.conntypes & NDMP9_CONFIG_CONNTYPE_LOCAL) {
590 reply2->methods.methods_val[i++] = NDMP2_ADDR_LOCAL;
591 }
592 if (reply9->config_info.conntypes & NDMP9_CONFIG_CONNTYPE_TCP) {
593 reply2->methods.methods_val[i++] = NDMP2_ADDR_TCP;
594 }
595 reply2->methods.methods_len = i;
596
597 return 0;
598 }
599
600
601 /*
602 * ndmp_config_get_auth_attr
603 */
604
ndmp_2to9_config_get_auth_attr_request(struct ndmp2_config_get_auth_attr_request * request2,struct ndmp9_config_get_auth_attr_request * request9)605 int ndmp_2to9_config_get_auth_attr_request(
606 struct ndmp2_config_get_auth_attr_request* request2,
607 struct ndmp9_config_get_auth_attr_request* request9)
608 {
609 int n_error = 0;
610 int rc;
611
612 rc = CNVT_E_TO_9(request2, request9, auth_type, ndmp_29_auth_type);
613 if (rc == NDMP_INVALID_GENERAL) {
614 CNVT_TO_9(request2, request9, auth_type);
615 n_error++;
616 }
617
618 return n_error;
619 }
620
ndmp_9to2_config_get_auth_attr_request(struct ndmp9_config_get_auth_attr_request * request9,struct ndmp2_config_get_auth_attr_request * request2)621 int ndmp_9to2_config_get_auth_attr_request(
622 struct ndmp9_config_get_auth_attr_request* request9,
623 struct ndmp2_config_get_auth_attr_request* request2)
624 {
625 int n_error = 0;
626 int rc;
627
628 rc = CNVT_E_FROM_9(request2, request9, auth_type, ndmp_29_auth_type);
629 if (rc == NDMP_INVALID_GENERAL) {
630 CNVT_FROM_9(request2, request9, auth_type);
631 n_error++;
632 }
633
634 return n_error;
635 }
636
ndmp_2to9_config_get_auth_attr_reply(struct ndmp2_config_get_auth_attr_reply * reply2,struct ndmp9_config_get_auth_attr_reply * reply9)637 int ndmp_2to9_config_get_auth_attr_reply(
638 struct ndmp2_config_get_auth_attr_reply* reply2,
639 struct ndmp9_config_get_auth_attr_reply* reply9)
640 {
641 int n_error = 0;
642
643 CNVT_E_TO_9(reply2, reply9, error, ndmp_29_error);
644
645 n_error += ndmp_2to9_auth_attr(&reply2->server_attr, &reply9->server_attr);
646
647 return n_error;
648 }
649
ndmp_9to2_config_get_auth_attr_reply(struct ndmp9_config_get_auth_attr_reply * reply9,struct ndmp2_config_get_auth_attr_reply * reply2)650 int ndmp_9to2_config_get_auth_attr_reply(
651 struct ndmp9_config_get_auth_attr_reply* reply9,
652 struct ndmp2_config_get_auth_attr_reply* reply2)
653 {
654 int n_error = 0;
655
656 CNVT_E_FROM_9(reply2, reply9, error, ndmp_29_error);
657
658 n_error += ndmp_9to2_auth_attr(&reply9->server_attr, &reply2->server_attr);
659
660 return n_error;
661 }
662
663
664 /*
665 * SCSI INTERFACES
666 ****************************************************************
667 */
668
669 /*
670 * ndmp_scsi_open
671 * just error reply
672 */
ndmp_2to9_scsi_open_request(ndmp2_scsi_open_request * request2,ndmp9_scsi_open_request * request9)673 int ndmp_2to9_scsi_open_request(ndmp2_scsi_open_request* request2,
674 ndmp9_scsi_open_request* request9)
675 {
676 request9->device = NDMOS_API_STRDUP(request2->device.name);
677 if (!request9->device) { return -1; /* no memory */ }
678 return 0;
679 }
680
ndmp_9to2_scsi_open_request(ndmp9_scsi_open_request * request9,ndmp2_scsi_open_request * request2)681 int ndmp_9to2_scsi_open_request(ndmp9_scsi_open_request* request9,
682 ndmp2_scsi_open_request* request2)
683 {
684 request2->device.name = NDMOS_API_STRDUP(request9->device);
685 if (!request2->device.name) { return -1; /* no memory */ }
686 return 0;
687 }
688
689 /*
690 * ndmp_scsi_close
691 * no args request, just error reply
692 */
693
694 /*
695 * ndmp_scsi_get_state
696 * no args request
697 */
698
ndmp_2to9_scsi_get_state_reply(ndmp2_scsi_get_state_reply * reply2,ndmp9_scsi_get_state_reply * reply9)699 int ndmp_2to9_scsi_get_state_reply(ndmp2_scsi_get_state_reply* reply2,
700 ndmp9_scsi_get_state_reply* reply9)
701 {
702 CNVT_E_TO_9(reply2, reply9, error, ndmp_29_error);
703 CNVT_TO_9(reply2, reply9, target_controller);
704 CNVT_TO_9(reply2, reply9, target_id);
705 CNVT_TO_9(reply2, reply9, target_lun);
706
707 return 0;
708 }
709
ndmp_9to2_scsi_get_state_reply(ndmp9_scsi_get_state_reply * reply9,ndmp2_scsi_get_state_reply * reply2)710 int ndmp_9to2_scsi_get_state_reply(ndmp9_scsi_get_state_reply* reply9,
711 ndmp2_scsi_get_state_reply* reply2)
712 {
713 CNVT_E_FROM_9(reply2, reply9, error, ndmp_29_error);
714 CNVT_FROM_9(reply2, reply9, target_controller);
715 CNVT_FROM_9(reply2, reply9, target_id);
716 CNVT_FROM_9(reply2, reply9, target_lun);
717
718 return 0;
719 }
720
721 /*
722 * ndmp_scsi_set_target -- deprecated
723 * just error reply
724 */
725
ndmp_2to9_scsi_set_target_request(ndmp2_scsi_set_target_request * request2,ndmp9_scsi_set_target_request * request9)726 int ndmp_2to9_scsi_set_target_request(ndmp2_scsi_set_target_request* request2,
727 ndmp9_scsi_set_target_request* request9)
728 {
729 request9->device = NDMOS_API_STRDUP(request2->device.name);
730 if (!request9->device) { return -1; /* no memory */ }
731
732 CNVT_TO_9(request2, request9, target_controller);
733 CNVT_TO_9(request2, request9, target_id);
734 CNVT_TO_9(request2, request9, target_lun);
735
736 return 0;
737 }
738
ndmp_9to2_scsi_set_target_request(ndmp9_scsi_set_target_request * request9,ndmp2_scsi_set_target_request * request2)739 int ndmp_9to2_scsi_set_target_request(ndmp9_scsi_set_target_request* request9,
740 ndmp2_scsi_set_target_request* request2)
741 {
742 request2->device.name = NDMOS_API_STRDUP(request9->device);
743 if (!request2->device.name) { return -1; /* no memory */ }
744
745 CNVT_FROM_9(request2, request9, target_controller);
746 CNVT_FROM_9(request2, request9, target_id);
747 CNVT_FROM_9(request2, request9, target_lun);
748
749 return 0;
750 }
751
752 /*
753 * ndmp_scsi_reset_device
754 * no args request, just error reply
755 */
756
757 /*
758 * ndmp_scsi_reset_bus -- deprecated
759 * no args request, just error reply
760 */
761
762
763 /*
764 * ndmp_tape_execute_cdb
765 * ndmp_scsi_execute_cdb
766 */
767
ndmp_2to9_execute_cdb_request(ndmp2_execute_cdb_request * request2,ndmp9_execute_cdb_request * request9)768 int ndmp_2to9_execute_cdb_request(ndmp2_execute_cdb_request* request2,
769 ndmp9_execute_cdb_request* request9)
770 {
771 int n_error = 0;
772 uint32_t len;
773 char* p;
774
775 switch (request2->flags) {
776 case 0:
777 request9->data_dir = NDMP9_SCSI_DATA_DIR_NONE;
778 break;
779
780 case NDMP2_SCSI_DATA_IN:
781 request9->data_dir = NDMP9_SCSI_DATA_DIR_IN;
782 break;
783
784 case NDMP2_SCSI_DATA_OUT:
785 request9->data_dir = NDMP9_SCSI_DATA_DIR_IN;
786 break;
787
788 default:
789 /* deemed insolvable */
790 n_error++;
791 return -1;
792 }
793
794 CNVT_TO_9(request2, request9, timeout);
795 CNVT_TO_9(request2, request9, datain_len);
796
797 len = request2->dataout.dataout_len;
798 if (len > 0) {
799 p = NDMOS_API_MALLOC(len);
800 if (!p) { return -1; }
801 NDMOS_API_BCOPY(request2->dataout.dataout_val, p, len);
802 } else {
803 len = 0;
804 p = 0;
805 }
806 request9->dataout.dataout_len = len;
807 request9->dataout.dataout_val = p;
808
809 len = request2->cdb.cdb_len;
810 if (len > 0) {
811 p = NDMOS_API_MALLOC(len);
812 if (!p) {
813 if (request9->dataout.dataout_val) {
814 NDMOS_API_FREE(request9->dataout.dataout_val);
815 request9->dataout.dataout_len = 0;
816 request9->dataout.dataout_val = 0;
817 }
818 return -1;
819 }
820 NDMOS_API_BCOPY(request2->cdb.cdb_val, p, len);
821 } else {
822 len = 0;
823 p = 0;
824 }
825 request9->cdb.cdb_len = len;
826 request9->cdb.cdb_val = p;
827
828 return 0;
829 }
830
ndmp_9to2_execute_cdb_request(ndmp9_execute_cdb_request * request9,ndmp2_execute_cdb_request * request2)831 int ndmp_9to2_execute_cdb_request(ndmp9_execute_cdb_request* request9,
832 ndmp2_execute_cdb_request* request2)
833 {
834 int n_error = 0;
835 uint32_t len;
836 char* p;
837
838 switch (request9->data_dir) {
839 case NDMP9_SCSI_DATA_DIR_NONE:
840 request2->flags = 0;
841 break;
842
843 case NDMP9_SCSI_DATA_DIR_IN:
844 request2->flags = NDMP2_SCSI_DATA_IN;
845 break;
846
847 case NDMP9_SCSI_DATA_DIR_OUT:
848 request2->flags = NDMP2_SCSI_DATA_OUT;
849 break;
850
851 default:
852 /* deemed insolvable */
853 n_error++;
854 return -1;
855 }
856
857 CNVT_FROM_9(request2, request9, timeout);
858 CNVT_FROM_9(request2, request9, datain_len);
859
860 len = request9->dataout.dataout_len;
861 if (len > 0) {
862 p = NDMOS_API_MALLOC(len);
863 if (!p) { return -1; }
864 NDMOS_API_BCOPY(request9->dataout.dataout_val, p, len);
865 } else {
866 len = 0;
867 p = 0;
868 }
869 request2->dataout.dataout_len = len;
870 request2->dataout.dataout_val = p;
871
872 len = request9->cdb.cdb_len;
873 if (len > 0) {
874 p = NDMOS_API_MALLOC(len);
875 if (!p) {
876 if (request2->dataout.dataout_val) {
877 NDMOS_API_FREE(request2->dataout.dataout_val);
878 request2->dataout.dataout_len = 0;
879 request2->dataout.dataout_val = 0;
880 }
881 return -1;
882 }
883 NDMOS_API_BCOPY(request9->cdb.cdb_val, p, len);
884 } else {
885 len = 0;
886 p = 0;
887 }
888 request2->cdb.cdb_len = len;
889 request2->cdb.cdb_val = p;
890
891 return 0;
892 }
893
ndmp_2to9_execute_cdb_reply(ndmp2_execute_cdb_reply * reply2,ndmp9_execute_cdb_reply * reply9)894 int ndmp_2to9_execute_cdb_reply(ndmp2_execute_cdb_reply* reply2,
895 ndmp9_execute_cdb_reply* reply9)
896 {
897 uint32_t len;
898 char* p;
899
900 CNVT_E_TO_9(reply2, reply9, error, ndmp_29_error);
901 CNVT_TO_9(reply2, reply9, status);
902 CNVT_TO_9(reply2, reply9, dataout_len);
903
904 len = reply2->datain.datain_len;
905 if (len > 0) {
906 p = NDMOS_API_MALLOC(len);
907 if (!p) { return -1; }
908 NDMOS_API_BCOPY(reply2->datain.datain_val, p, len);
909 } else {
910 len = 0;
911 p = 0;
912 }
913 reply9->datain.datain_len = len;
914 reply9->datain.datain_val = p;
915
916 len = reply2->ext_sense.ext_sense_len;
917 if (len > 0) {
918 p = NDMOS_API_MALLOC(len);
919 if (!p) {
920 if (reply9->datain.datain_val) {
921 NDMOS_API_FREE(reply9->datain.datain_val);
922 reply9->datain.datain_len = 0;
923 reply9->datain.datain_val = 0;
924 }
925 return -1;
926 }
927 NDMOS_API_BCOPY(reply2->ext_sense.ext_sense_val, p, len);
928 } else {
929 len = 0;
930 p = 0;
931 }
932 reply9->ext_sense.ext_sense_len = len;
933 reply9->ext_sense.ext_sense_val = p;
934
935 return 0;
936 }
937
ndmp_9to2_execute_cdb_reply(ndmp9_execute_cdb_reply * reply9,ndmp2_execute_cdb_reply * reply2)938 int ndmp_9to2_execute_cdb_reply(ndmp9_execute_cdb_reply* reply9,
939 ndmp2_execute_cdb_reply* reply2)
940 {
941 uint32_t len;
942 char* p;
943
944 CNVT_E_FROM_9(reply2, reply9, error, ndmp_29_error);
945 CNVT_FROM_9(reply2, reply9, status);
946 CNVT_FROM_9(reply2, reply9, dataout_len);
947
948 len = reply9->datain.datain_len;
949 if (len > 0) {
950 p = NDMOS_API_MALLOC(len);
951 if (!p) { return -1; }
952 NDMOS_API_BCOPY(reply9->datain.datain_val, p, len);
953 } else {
954 len = 0;
955 p = 0;
956 }
957 reply2->datain.datain_len = len;
958 reply2->datain.datain_val = p;
959
960 len = reply9->ext_sense.ext_sense_len;
961 if (len > 0) {
962 p = NDMOS_API_MALLOC(len);
963 if (!p) {
964 if (reply2->datain.datain_val) {
965 NDMOS_API_FREE(reply9->datain.datain_val);
966 reply2->datain.datain_len = 0;
967 reply2->datain.datain_val = 0;
968 }
969 return -1;
970 }
971 NDMOS_API_BCOPY(reply9->ext_sense.ext_sense_val, p, len);
972 } else {
973 len = 0;
974 p = 0;
975 }
976 reply2->ext_sense.ext_sense_len = len;
977 reply2->ext_sense.ext_sense_val = p;
978
979 return 0;
980 }
981
982
983 /*
984 * TAPE INTERFACES
985 ****************************************************************
986 */
987
988
989 /*
990 * ndmp_tape_open_request
991 * just error reply
992 */
993
994 struct enum_conversion ndmp_29_tape_open_mode[] = {
995 {
996 NDMP_INVALID_GENERAL,
997 NDMP_INVALID_GENERAL,
998 }, /* default */
999 {NDMP2_TAPE_READ_MODE, NDMP9_TAPE_READ_MODE},
1000 {NDMP2_TAPE_WRITE_MODE, NDMP9_TAPE_RDWR_MODE},
1001 END_ENUM_CONVERSION_TABLE};
1002
1003
ndmp_2to9_tape_open_request(ndmp2_tape_open_request * request2,ndmp9_tape_open_request * request9)1004 int ndmp_2to9_tape_open_request(ndmp2_tape_open_request* request2,
1005 ndmp9_tape_open_request* request9)
1006 {
1007 int n_error = 0;
1008 int rc;
1009
1010 /*
1011 * Mode codes are compatible between versions.
1012 * We let untranslated values through to
1013 * facilitate testing illegal values.
1014 */
1015 rc = convert_enum_to_9(ndmp_29_tape_open_mode, request2->mode);
1016 if (rc == NDMP_INVALID_GENERAL) {
1017 n_error++;
1018 request9->mode = request2->mode;
1019 } else {
1020 request9->mode = rc;
1021 }
1022
1023 request9->device = NDMOS_API_STRDUP(request2->device.name);
1024 if (!request9->device) { return -1; /* no memory */ }
1025
1026 return n_error;
1027 }
1028
ndmp_9to2_tape_open_request(ndmp9_tape_open_request * request9,ndmp2_tape_open_request * request2)1029 int ndmp_9to2_tape_open_request(ndmp9_tape_open_request* request9,
1030 ndmp2_tape_open_request* request2)
1031 {
1032 int n_error = 0;
1033 int rc;
1034
1035 rc = convert_enum_from_9(ndmp_29_tape_open_mode, request9->mode);
1036 if (rc == NDMP_INVALID_GENERAL) {
1037 n_error++;
1038 request2->mode = request9->mode;
1039 } else {
1040 request2->mode = rc;
1041 }
1042
1043 request2->device.name = NDMOS_API_STRDUP(request9->device);
1044 if (!request2->device.name) { return -1; /* no memory */ }
1045
1046 return n_error;
1047 }
1048
1049
1050 /*
1051 * ndmp_tape_close
1052 * no arg request, just error reply
1053 */
1054
1055
1056 /*
1057 * ndmp_tape_get_state_reply
1058 * no arg request
1059 */
1060
ndmp_2to9_tape_get_state_reply(ndmp2_tape_get_state_reply * reply2,ndmp9_tape_get_state_reply * reply9)1061 int ndmp_2to9_tape_get_state_reply(ndmp2_tape_get_state_reply* reply2,
1062 ndmp9_tape_get_state_reply* reply9)
1063 {
1064 CNVT_E_TO_9(reply2, reply9, error, ndmp_29_error);
1065 CNVT_TO_9(reply2, reply9, flags);
1066 CNVT_VUL_TO_9(reply2, reply9, file_num);
1067 CNVT_VUL_TO_9(reply2, reply9, soft_errors);
1068 CNVT_VUL_TO_9(reply2, reply9, block_size);
1069 CNVT_VUL_TO_9(reply2, reply9, blockno);
1070 CNVT_VUQ_TO_9(reply2, reply9, total_space);
1071 CNVT_VUQ_TO_9(reply2, reply9, space_remain);
1072
1073 return 0;
1074 }
1075
ndmp_9to2_tape_get_state_reply(ndmp9_tape_get_state_reply * reply9,ndmp2_tape_get_state_reply * reply2)1076 int ndmp_9to2_tape_get_state_reply(ndmp9_tape_get_state_reply* reply9,
1077 ndmp2_tape_get_state_reply* reply2)
1078 {
1079 CNVT_E_FROM_9(reply2, reply9, error, ndmp_29_error);
1080 CNVT_FROM_9(reply2, reply9, flags);
1081 CNVT_VUL_FROM_9(reply2, reply9, file_num);
1082 CNVT_VUL_FROM_9(reply2, reply9, soft_errors);
1083 CNVT_VUL_FROM_9(reply2, reply9, block_size);
1084 CNVT_VUL_FROM_9(reply2, reply9, blockno);
1085 CNVT_VUQ_FROM_9(reply2, reply9, total_space);
1086 CNVT_VUQ_FROM_9(reply2, reply9, space_remain);
1087
1088 return 0;
1089 }
1090
1091
1092 /*
1093 * ndmp_tape_mtio_request
1094 */
1095
1096 struct enum_conversion ndmp_29_tape_mtio_op[] = {
1097 {
1098 NDMP_INVALID_GENERAL,
1099 NDMP_INVALID_GENERAL,
1100 }, /* default */
1101 {NDMP2_MTIO_FSF, NDMP9_MTIO_FSF},
1102 {NDMP2_MTIO_BSF, NDMP9_MTIO_BSF},
1103 {NDMP2_MTIO_FSR, NDMP9_MTIO_FSR},
1104 {NDMP2_MTIO_BSR, NDMP9_MTIO_BSR},
1105 {NDMP2_MTIO_REW, NDMP9_MTIO_REW},
1106 {NDMP2_MTIO_EOF, NDMP9_MTIO_EOF},
1107 {NDMP2_MTIO_OFF, NDMP9_MTIO_OFF},
1108 END_ENUM_CONVERSION_TABLE};
1109
1110
ndmp_2to9_tape_mtio_request(ndmp2_tape_mtio_request * request2,ndmp9_tape_mtio_request * request9)1111 int ndmp_2to9_tape_mtio_request(ndmp2_tape_mtio_request* request2,
1112 ndmp9_tape_mtio_request* request9)
1113 {
1114 int n_error = 0;
1115 int rc;
1116
1117 rc = CNVT_E_TO_9(request2, request9, tape_op, ndmp_29_tape_mtio_op);
1118 if (rc == NDMP_INVALID_GENERAL) {
1119 n_error++;
1120 CNVT_TO_9(request2, request9, tape_op);
1121 }
1122
1123 CNVT_TO_9(request2, request9, count);
1124
1125 return n_error;
1126 }
1127
ndmp_9to2_tape_mtio_request(ndmp9_tape_mtio_request * request9,ndmp2_tape_mtio_request * request2)1128 int ndmp_9to2_tape_mtio_request(ndmp9_tape_mtio_request* request9,
1129 ndmp2_tape_mtio_request* request2)
1130 {
1131 int n_error = 0;
1132 int rc;
1133
1134 rc = CNVT_E_FROM_9(request2, request9, tape_op, ndmp_29_tape_mtio_op);
1135 if (rc == NDMP_INVALID_GENERAL) {
1136 n_error++;
1137 CNVT_FROM_9(request2, request9, tape_op);
1138 }
1139
1140 CNVT_FROM_9(request2, request9, count);
1141
1142 return n_error;
1143 }
1144
ndmp_2to9_tape_mtio_reply(ndmp2_tape_mtio_reply * reply2,ndmp9_tape_mtio_reply * reply9)1145 int ndmp_2to9_tape_mtio_reply(ndmp2_tape_mtio_reply* reply2,
1146 ndmp9_tape_mtio_reply* reply9)
1147 {
1148 CNVT_E_TO_9(reply2, reply9, error, ndmp_29_error);
1149 CNVT_TO_9(reply2, reply9, resid_count);
1150 return 0;
1151 }
1152
ndmp_9to2_tape_mtio_reply(ndmp9_tape_mtio_reply * reply9,ndmp2_tape_mtio_reply * reply2)1153 int ndmp_9to2_tape_mtio_reply(ndmp9_tape_mtio_reply* reply9,
1154 ndmp2_tape_mtio_reply* reply2)
1155 {
1156 CNVT_E_FROM_9(reply2, reply9, error, ndmp_29_error);
1157 CNVT_FROM_9(reply2, reply9, resid_count);
1158 return 0;
1159 }
1160
1161
1162 /*
1163 * ndmp_tape_write
1164 */
1165
ndmp_2to9_tape_write_request(ndmp2_tape_write_request * request2,ndmp9_tape_write_request * request9)1166 int ndmp_2to9_tape_write_request(ndmp2_tape_write_request* request2,
1167 ndmp9_tape_write_request* request9)
1168 {
1169 uint32_t len;
1170 char* p;
1171
1172 len = request2->data_out.data_out_len;
1173
1174 p = NDMOS_API_MALLOC(len);
1175 if (!p) { return -1; }
1176
1177 NDMOS_API_BCOPY(request2->data_out.data_out_val, p, len);
1178
1179 request9->data_out.data_out_val = p;
1180 request9->data_out.data_out_len = len;
1181
1182 return 0;
1183 }
1184
ndmp_9to2_tape_write_request(ndmp9_tape_write_request * request9,ndmp2_tape_write_request * request2)1185 int ndmp_9to2_tape_write_request(ndmp9_tape_write_request* request9,
1186 ndmp2_tape_write_request* request2)
1187 {
1188 uint32_t len;
1189 char* p;
1190
1191 len = request9->data_out.data_out_len;
1192
1193 p = NDMOS_API_MALLOC(len);
1194 if (!p) { return -1; }
1195
1196 NDMOS_API_BCOPY(request9->data_out.data_out_val, p, len);
1197
1198 request2->data_out.data_out_val = p;
1199 request2->data_out.data_out_len = len;
1200
1201 return 0;
1202 }
1203
ndmp_2to9_tape_write_reply(ndmp2_tape_write_reply * reply2,ndmp9_tape_write_reply * reply9)1204 int ndmp_2to9_tape_write_reply(ndmp2_tape_write_reply* reply2,
1205 ndmp9_tape_write_reply* reply9)
1206 {
1207 CNVT_E_TO_9(reply2, reply9, error, ndmp_29_error);
1208 CNVT_TO_9(reply2, reply9, count);
1209 return 0;
1210 }
1211
ndmp_9to2_tape_write_reply(ndmp9_tape_write_reply * reply9,ndmp2_tape_write_reply * reply2)1212 int ndmp_9to2_tape_write_reply(ndmp9_tape_write_reply* reply9,
1213 ndmp2_tape_write_reply* reply2)
1214 {
1215 CNVT_E_FROM_9(reply2, reply9, error, ndmp_29_error);
1216 CNVT_FROM_9(reply2, reply9, count);
1217 return 0;
1218 }
1219
1220
1221 /*
1222 * ndmp_tape_read
1223 */
1224
ndmp_2to9_tape_read_request(ndmp2_tape_read_request * request2,ndmp9_tape_read_request * request9)1225 int ndmp_2to9_tape_read_request(ndmp2_tape_read_request* request2,
1226 ndmp9_tape_read_request* request9)
1227 {
1228 CNVT_TO_9(request2, request9, count);
1229 return 0;
1230 }
1231
ndmp_9to2_tape_read_request(ndmp9_tape_read_request * request9,ndmp2_tape_read_request * request2)1232 int ndmp_9to2_tape_read_request(ndmp9_tape_read_request* request9,
1233 ndmp2_tape_read_request* request2)
1234 {
1235 CNVT_FROM_9(request2, request9, count);
1236 return 0;
1237 }
1238
ndmp_2to9_tape_read_reply(ndmp2_tape_read_reply * reply2,ndmp9_tape_read_reply * reply9)1239 int ndmp_2to9_tape_read_reply(ndmp2_tape_read_reply* reply2,
1240 ndmp9_tape_read_reply* reply9)
1241 {
1242 uint32_t len;
1243 char* p;
1244
1245 CNVT_E_TO_9(reply2, reply9, error, ndmp_29_error);
1246
1247 len = reply2->data_in.data_in_len;
1248 if (len > 0) {
1249 p = NDMOS_API_MALLOC(len);
1250 if (!p) { return -1; }
1251 NDMOS_API_BCOPY(reply2->data_in.data_in_val, p, len);
1252 } else {
1253 p = 0;
1254 len = 0;
1255 }
1256
1257 reply9->data_in.data_in_len = len;
1258 reply9->data_in.data_in_val = p;
1259
1260 return 0;
1261 }
1262
ndmp_9to2_tape_read_reply(ndmp9_tape_read_reply * reply9,ndmp2_tape_read_reply * reply2)1263 int ndmp_9to2_tape_read_reply(ndmp9_tape_read_reply* reply9,
1264 ndmp2_tape_read_reply* reply2)
1265 {
1266 uint32_t len;
1267 char* p;
1268
1269 CNVT_E_FROM_9(reply2, reply9, error, ndmp_29_error);
1270
1271 len = reply9->data_in.data_in_len;
1272 if (len > 0) {
1273 p = NDMOS_API_MALLOC(len);
1274 if (!p) { return -1; }
1275 NDMOS_API_BCOPY(reply9->data_in.data_in_val, p, len);
1276 } else {
1277 p = 0;
1278 len = 0;
1279 }
1280
1281 reply2->data_in.data_in_len = len;
1282 reply2->data_in.data_in_val = p;
1283
1284 return 0;
1285 }
1286
1287 /*
1288 * ndmp_tape_execute_cdb
1289 * see SCSI INTERFACES above
1290 */
1291
1292
1293 /*
1294 * MOVER INTERFACES
1295 ****************************************************************
1296 */
1297
1298 /*
1299 * ndmp_mover_get_state
1300 * no args request
1301 */
1302
1303 struct enum_conversion ndmp_29_mover_mode[] = {
1304 {
1305 NDMP_INVALID_GENERAL,
1306 NDMP_INVALID_GENERAL,
1307 }, /* default */
1308 {NDMP2_MOVER_MODE_READ, NDMP9_MOVER_MODE_READ},
1309 {NDMP2_MOVER_MODE_WRITE, NDMP9_MOVER_MODE_WRITE},
1310
1311 END_ENUM_CONVERSION_TABLE};
1312
1313 struct enum_conversion ndmp_29_mover_state[] = {
1314 {
1315 NDMP_INVALID_GENERAL,
1316 NDMP_INVALID_GENERAL,
1317 }, /* default */
1318 {NDMP2_MOVER_STATE_IDLE, NDMP9_MOVER_STATE_IDLE},
1319 {NDMP2_MOVER_STATE_LISTEN, NDMP9_MOVER_STATE_LISTEN},
1320 {NDMP2_MOVER_STATE_ACTIVE, NDMP9_MOVER_STATE_ACTIVE},
1321 {NDMP2_MOVER_STATE_PAUSED, NDMP9_MOVER_STATE_PAUSED},
1322 {NDMP2_MOVER_STATE_HALTED, NDMP9_MOVER_STATE_HALTED},
1323
1324 /* alias */
1325 {NDMP2_MOVER_STATE_ACTIVE, NDMP9_MOVER_STATE_STANDBY},
1326
1327 END_ENUM_CONVERSION_TABLE};
1328
1329 struct enum_conversion ndmp_29_mover_pause_reason[] = {
1330 {
1331 NDMP_INVALID_GENERAL,
1332 NDMP_INVALID_GENERAL,
1333 }, /* default */
1334 {NDMP2_MOVER_PAUSE_NA, NDMP9_MOVER_PAUSE_NA},
1335 {NDMP2_MOVER_PAUSE_EOM, NDMP9_MOVER_PAUSE_EOM},
1336 {NDMP2_MOVER_PAUSE_EOF, NDMP9_MOVER_PAUSE_EOF},
1337 {NDMP2_MOVER_PAUSE_SEEK, NDMP9_MOVER_PAUSE_SEEK},
1338 {NDMP2_MOVER_PAUSE_MEDIA_ERROR, NDMP9_MOVER_PAUSE_MEDIA_ERROR},
1339 END_ENUM_CONVERSION_TABLE};
1340
1341 struct enum_conversion ndmp_29_mover_halt_reason[] = {
1342 {
1343 NDMP_INVALID_GENERAL,
1344 NDMP_INVALID_GENERAL,
1345 }, /* default */
1346 {NDMP2_MOVER_HALT_NA, NDMP9_MOVER_HALT_NA},
1347 {NDMP2_MOVER_HALT_CONNECT_CLOSED, NDMP9_MOVER_HALT_CONNECT_CLOSED},
1348 {NDMP2_MOVER_HALT_ABORTED, NDMP9_MOVER_HALT_ABORTED},
1349 {NDMP2_MOVER_HALT_INTERNAL_ERROR, NDMP9_MOVER_HALT_INTERNAL_ERROR},
1350 {NDMP2_MOVER_HALT_CONNECT_ERROR, NDMP9_MOVER_HALT_CONNECT_ERROR},
1351 END_ENUM_CONVERSION_TABLE};
1352
1353
ndmp_2to9_mover_get_state_reply(ndmp2_mover_get_state_reply * reply2,ndmp9_mover_get_state_reply * reply9)1354 int ndmp_2to9_mover_get_state_reply(ndmp2_mover_get_state_reply* reply2,
1355 ndmp9_mover_get_state_reply* reply9)
1356 {
1357 CNVT_E_TO_9(reply2, reply9, error, ndmp_29_error);
1358 CNVT_E_TO_9(reply2, reply9, state, ndmp_29_mover_state);
1359 CNVT_E_TO_9(reply2, reply9, pause_reason, ndmp_29_mover_pause_reason);
1360 CNVT_E_TO_9(reply2, reply9, halt_reason, ndmp_29_mover_halt_reason);
1361
1362 CNVT_TO_9(reply2, reply9, record_size);
1363 CNVT_TO_9(reply2, reply9, record_num);
1364 CNVT_TO_9x(reply2, reply9, data_written, bytes_moved);
1365 CNVT_TO_9(reply2, reply9, seek_position);
1366 CNVT_TO_9(reply2, reply9, bytes_left_to_read);
1367 CNVT_TO_9(reply2, reply9, window_offset);
1368 CNVT_TO_9(reply2, reply9, window_length);
1369
1370 return 0;
1371 }
1372
ndmp_9to2_mover_get_state_reply(ndmp9_mover_get_state_reply * reply9,ndmp2_mover_get_state_reply * reply2)1373 int ndmp_9to2_mover_get_state_reply(ndmp9_mover_get_state_reply* reply9,
1374 ndmp2_mover_get_state_reply* reply2)
1375 {
1376 CNVT_E_FROM_9(reply2, reply9, error, ndmp_29_error);
1377 CNVT_E_FROM_9(reply2, reply9, state, ndmp_29_mover_state);
1378 CNVT_E_FROM_9(reply2, reply9, pause_reason, ndmp_29_mover_pause_reason);
1379 CNVT_E_FROM_9(reply2, reply9, halt_reason, ndmp_29_mover_halt_reason);
1380
1381 CNVT_FROM_9(reply2, reply9, record_size);
1382 CNVT_FROM_9(reply2, reply9, record_num);
1383 CNVT_FROM_9x(reply2, reply9, data_written, bytes_moved);
1384 CNVT_FROM_9(reply2, reply9, seek_position);
1385 CNVT_FROM_9(reply2, reply9, bytes_left_to_read);
1386 CNVT_FROM_9(reply2, reply9, window_offset);
1387 CNVT_FROM_9(reply2, reply9, window_length);
1388
1389 return 0;
1390 }
1391
1392
1393 /*
1394 * ndmp_mover_listen
1395 */
1396
ndmp_2to9_mover_listen_request(ndmp2_mover_listen_request * request2,ndmp9_mover_listen_request * request9)1397 int ndmp_2to9_mover_listen_request(ndmp2_mover_listen_request* request2,
1398 ndmp9_mover_listen_request* request9)
1399 {
1400 int rc;
1401
1402 rc = CNVT_E_TO_9(request2, request9, mode, ndmp_29_mover_mode);
1403 if (rc == NDMP_INVALID_GENERAL) { CNVT_TO_9(request2, request9, mode); }
1404 rc = CNVT_E_TO_9(request2, request9, addr_type, ndmp_29_mover_addr_type);
1405 if (rc == NDMP_INVALID_GENERAL) { CNVT_TO_9(request2, request9, addr_type); }
1406
1407 return 0;
1408 }
1409
ndmp_9to2_mover_listen_request(ndmp9_mover_listen_request * request9,ndmp2_mover_listen_request * request2)1410 int ndmp_9to2_mover_listen_request(ndmp9_mover_listen_request* request9,
1411 ndmp2_mover_listen_request* request2)
1412 {
1413 int rc;
1414
1415 rc = CNVT_E_FROM_9(request2, request9, mode, ndmp_29_mover_mode);
1416 if (rc == NDMP_INVALID_GENERAL) { CNVT_FROM_9(request2, request9, mode); }
1417 rc = CNVT_E_FROM_9(request2, request9, addr_type, ndmp_29_mover_addr_type);
1418 if (rc == NDMP_INVALID_GENERAL) {
1419 CNVT_FROM_9(request2, request9, addr_type);
1420 }
1421
1422 return 0;
1423 }
1424
ndmp_2to9_mover_listen_reply(ndmp2_mover_listen_reply * reply2,ndmp9_mover_listen_reply * reply9)1425 int ndmp_2to9_mover_listen_reply(ndmp2_mover_listen_reply* reply2,
1426 ndmp9_mover_listen_reply* reply9)
1427 {
1428 int n_error = 0;
1429
1430 CNVT_E_TO_9(reply2, reply9, error, ndmp_29_error);
1431
1432 n_error +=
1433 ndmp_2to9_mover_addr(&reply2->mover, &reply9->data_connection_addr);
1434
1435 return n_error;
1436 }
1437
ndmp_9to2_mover_listen_reply(ndmp9_mover_listen_reply * reply9,ndmp2_mover_listen_reply * reply2)1438 int ndmp_9to2_mover_listen_reply(ndmp9_mover_listen_reply* reply9,
1439 ndmp2_mover_listen_reply* reply2)
1440 {
1441 int n_error = 0;
1442
1443 CNVT_E_FROM_9(reply2, reply9, error, ndmp_29_error);
1444
1445 n_error +=
1446 ndmp_9to2_mover_addr(&reply9->data_connection_addr, &reply2->mover);
1447
1448 return n_error;
1449 }
1450
1451 /*
1452 * ndmp_mover_continue
1453 * no args request, just error reply
1454 */
1455
1456 /*
1457 * ndmp_mover_abort
1458 * no args request, just error reply
1459 */
1460
1461 /*
1462 * ndmp_mover_stop
1463 * no args request, just error reply
1464 */
1465
1466 /*
1467 * ndmp_mover_set_window
1468 * just error reply
1469 */
1470
ndmp_2to9_mover_set_window_request(ndmp2_mover_set_window_request * request2,ndmp9_mover_set_window_request * request9)1471 int ndmp_2to9_mover_set_window_request(ndmp2_mover_set_window_request* request2,
1472 ndmp9_mover_set_window_request* request9)
1473 {
1474 CNVT_TO_9(request2, request9, offset);
1475 CNVT_TO_9(request2, request9, length);
1476 return 0;
1477 }
1478
ndmp_9to2_mover_set_window_request(ndmp9_mover_set_window_request * request9,ndmp2_mover_set_window_request * request2)1479 int ndmp_9to2_mover_set_window_request(ndmp9_mover_set_window_request* request9,
1480 ndmp2_mover_set_window_request* request2)
1481 {
1482 CNVT_FROM_9(request2, request9, offset);
1483 CNVT_FROM_9(request2, request9, length);
1484 return 0;
1485 }
1486
1487
1488 /*
1489 * ndmp_mover_read
1490 * just error reply
1491 */
1492
ndmp_2to9_mover_read_request(ndmp2_mover_read_request * request2,ndmp9_mover_read_request * request9)1493 int ndmp_2to9_mover_read_request(ndmp2_mover_read_request* request2,
1494 ndmp9_mover_read_request* request9)
1495 {
1496 CNVT_TO_9(request2, request9, offset);
1497 CNVT_TO_9(request2, request9, length);
1498 return 0;
1499 }
1500
ndmp_9to2_mover_read_request(ndmp9_mover_read_request * request9,ndmp2_mover_read_request * request2)1501 int ndmp_9to2_mover_read_request(ndmp9_mover_read_request* request9,
1502 ndmp2_mover_read_request* request2)
1503 {
1504 CNVT_FROM_9(request2, request9, offset);
1505 CNVT_FROM_9(request2, request9, length);
1506 return 0;
1507 }
1508
1509 /*
1510 * ndmp_mover_close
1511 * no args request, just error reply
1512 */
1513
1514
1515 /*
1516 * ndmp_mover_set_record_size
1517 * just error reply
1518 */
1519
ndmp_2to9_mover_set_record_size_request(ndmp2_mover_set_record_size_request * request2,ndmp9_mover_set_record_size_request * request9)1520 int ndmp_2to9_mover_set_record_size_request(
1521 ndmp2_mover_set_record_size_request* request2,
1522 ndmp9_mover_set_record_size_request* request9)
1523 {
1524 CNVT_TO_9x(request2, request9, len, record_size);
1525 return 0;
1526 }
1527
ndmp_9to2_mover_set_record_size_request(ndmp9_mover_set_record_size_request * request9,ndmp2_mover_set_record_size_request * request2)1528 int ndmp_9to2_mover_set_record_size_request(
1529 ndmp9_mover_set_record_size_request* request9,
1530 ndmp2_mover_set_record_size_request* request2)
1531 {
1532 CNVT_FROM_9x(request2, request9, len, record_size);
1533 return 0;
1534 }
1535
1536
1537 /*
1538 * DATA INTERFACES
1539 ****************************************************************
1540 */
1541
1542 /*
1543 * ndmp_name
1544 ****************************************************************
1545 */
1546
ndmp_2to9_name(ndmp2_name * name2,ndmp9_name * name9)1547 int ndmp_2to9_name(ndmp2_name* name2, ndmp9_name* name9)
1548 {
1549 name9->original_path = NDMOS_API_STRDUP(name2->name);
1550 name9->destination_path = NDMOS_API_STRDUP(name2->dest);
1551 if (name2->fh_info != NDMP_INVALID_U_QUAD) {
1552 name9->fh_info.valid = NDMP9_VALIDITY_VALID;
1553 name9->fh_info.value = name2->fh_info;
1554 } else {
1555 name9->fh_info.valid = NDMP9_VALIDITY_INVALID;
1556 name9->fh_info.value = NDMP_INVALID_U_QUAD;
1557 }
1558
1559 return 0;
1560 }
1561
ndmp_9to2_name(ndmp9_name * name9,ndmp2_name * name2)1562 int ndmp_9to2_name(ndmp9_name* name9, ndmp2_name* name2)
1563 {
1564 name2->name = NDMOS_API_STRDUP(name9->original_path);
1565 name2->dest = NDMOS_API_STRDUP(name9->destination_path);
1566 if (name9->fh_info.valid == NDMP9_VALIDITY_VALID) {
1567 name2->fh_info = name9->fh_info.value;
1568 } else {
1569 name2->fh_info = NDMP_INVALID_U_QUAD;
1570 }
1571
1572 name2->ssid = 0;
1573
1574 return 0;
1575 }
1576
ndmp_2to9_name_vec(ndmp2_name * name2,ndmp9_name * name9,unsigned n_name)1577 int ndmp_2to9_name_vec(ndmp2_name* name2, ndmp9_name* name9, unsigned n_name)
1578 {
1579 unsigned int i;
1580
1581 for (i = 0; i < n_name; i++) ndmp_2to9_name(&name2[i], &name9[i]);
1582
1583 return 0;
1584 }
1585
ndmp_9to2_name_vec(ndmp9_name * name9,ndmp2_name * name2,unsigned n_name)1586 int ndmp_9to2_name_vec(ndmp9_name* name9, ndmp2_name* name2, unsigned n_name)
1587 {
1588 unsigned int i;
1589
1590 for (i = 0; i < n_name; i++) ndmp_9to2_name(&name9[i], &name2[i]);
1591
1592 return 0;
1593 }
1594
ndmp_2to9_name_vec_dup(ndmp2_name * name2,ndmp9_name ** name9_p,unsigned n_name)1595 int ndmp_2to9_name_vec_dup(ndmp2_name* name2,
1596 ndmp9_name** name9_p,
1597 unsigned n_name)
1598 {
1599 *name9_p = NDMOS_MACRO_NEWN(ndmp9_name, n_name);
1600 if (!*name9_p) return -1;
1601
1602 return ndmp_2to9_name_vec(name2, *name9_p, n_name);
1603 }
1604
ndmp_9to2_name_vec_dup(ndmp9_name * name9,ndmp2_name ** name2_p,unsigned n_name)1605 int ndmp_9to2_name_vec_dup(ndmp9_name* name9,
1606 ndmp2_name** name2_p,
1607 unsigned n_name)
1608 {
1609 *name2_p = NDMOS_MACRO_NEWN(ndmp2_name, n_name);
1610 if (!*name2_p) return -1;
1611
1612 return ndmp_9to2_name_vec(name9, *name2_p, n_name);
1613 }
1614
1615
1616 /*
1617 * ndmp_data_get_state
1618 * no args request
1619 */
1620
1621 struct enum_conversion ndmp_29_data_operation[] = {
1622 {
1623 NDMP_INVALID_GENERAL,
1624 NDMP_INVALID_GENERAL,
1625 }, /* default */
1626 {NDMP2_DATA_OP_NOACTION, NDMP9_DATA_OP_NOACTION},
1627 {NDMP2_DATA_OP_BACKUP, NDMP9_DATA_OP_BACKUP},
1628 {NDMP2_DATA_OP_RESTORE, NDMP9_DATA_OP_RECOVER},
1629 {NDMP2_DATA_OP_RESTORE_FILEHIST, NDMP9_DATA_OP_RECOVER_FILEHIST},
1630 END_ENUM_CONVERSION_TABLE};
1631
1632 struct enum_conversion ndmp_29_data_state[] = {
1633 {
1634 NDMP_INVALID_GENERAL,
1635 NDMP_INVALID_GENERAL,
1636 }, /* default */
1637 {NDMP2_DATA_STATE_IDLE, NDMP9_DATA_STATE_IDLE},
1638 {NDMP2_DATA_STATE_ACTIVE, NDMP9_DATA_STATE_ACTIVE},
1639 {NDMP2_DATA_STATE_HALTED, NDMP9_DATA_STATE_HALTED},
1640
1641 /* aliases */
1642 {NDMP2_DATA_STATE_ACTIVE, NDMP9_DATA_STATE_CONNECTED},
1643 {NDMP2_DATA_STATE_ACTIVE, NDMP9_DATA_STATE_LISTEN},
1644
1645 END_ENUM_CONVERSION_TABLE};
1646
1647 struct enum_conversion ndmp_29_data_halt_reason[] = {
1648 {
1649 NDMP_INVALID_GENERAL,
1650 NDMP_INVALID_GENERAL,
1651 }, /* default */
1652 {NDMP2_DATA_HALT_NA, NDMP9_DATA_HALT_NA},
1653 {NDMP2_DATA_HALT_SUCCESSFUL, NDMP9_DATA_HALT_SUCCESSFUL},
1654 {NDMP2_DATA_HALT_ABORTED, NDMP9_DATA_HALT_ABORTED},
1655 {NDMP2_DATA_HALT_INTERNAL_ERROR, NDMP9_DATA_HALT_INTERNAL_ERROR},
1656 {NDMP2_DATA_HALT_CONNECT_ERROR, NDMP9_DATA_HALT_CONNECT_ERROR},
1657 END_ENUM_CONVERSION_TABLE};
1658
1659
ndmp_2to9_data_get_state_reply(ndmp2_data_get_state_reply * reply2,ndmp9_data_get_state_reply * reply9)1660 int ndmp_2to9_data_get_state_reply(ndmp2_data_get_state_reply* reply2,
1661 ndmp9_data_get_state_reply* reply9)
1662 {
1663 CNVT_E_TO_9(reply2, reply9, error, ndmp_29_error);
1664 CNVT_E_TO_9(reply2, reply9, operation, ndmp_29_data_operation);
1665 CNVT_E_TO_9(reply2, reply9, state, ndmp_29_data_state);
1666 CNVT_E_TO_9(reply2, reply9, halt_reason, ndmp_29_data_halt_reason);
1667
1668 CNVT_TO_9(reply2, reply9, bytes_processed);
1669
1670 CNVT_VUQ_TO_9(reply2, reply9, est_bytes_remain);
1671 CNVT_VUL_TO_9(reply2, reply9, est_time_remain);
1672
1673 ndmp_2to9_mover_addr(&reply2->mover, &reply9->data_connection_addr);
1674
1675 CNVT_TO_9(reply2, reply9, read_offset);
1676 CNVT_TO_9(reply2, reply9, read_length);
1677
1678 return 0;
1679 }
1680
ndmp_9to2_data_get_state_reply(ndmp9_data_get_state_reply * reply9,ndmp2_data_get_state_reply * reply2)1681 int ndmp_9to2_data_get_state_reply(ndmp9_data_get_state_reply* reply9,
1682 ndmp2_data_get_state_reply* reply2)
1683 {
1684 CNVT_E_FROM_9(reply2, reply9, error, ndmp_29_error);
1685 CNVT_E_FROM_9(reply2, reply9, operation, ndmp_29_data_operation);
1686 CNVT_E_FROM_9(reply2, reply9, state, ndmp_29_data_state);
1687 CNVT_E_FROM_9(reply2, reply9, halt_reason, ndmp_29_data_halt_reason);
1688
1689 CNVT_FROM_9(reply2, reply9, bytes_processed);
1690
1691 CNVT_VUQ_FROM_9(reply2, reply9, est_bytes_remain);
1692 CNVT_VUL_FROM_9(reply2, reply9, est_time_remain);
1693
1694 ndmp_9to2_mover_addr(&reply9->data_connection_addr, &reply2->mover);
1695
1696 CNVT_FROM_9(reply2, reply9, read_offset);
1697 CNVT_FROM_9(reply2, reply9, read_length);
1698
1699 return 0;
1700 }
1701
1702 /*
1703 * ndmp_data_start_backup
1704 * just error reply
1705 */
1706
ndmp_2to9_data_start_backup_request(ndmp2_data_start_backup_request * request2,ndmp9_data_start_backup_request * request9)1707 int ndmp_2to9_data_start_backup_request(
1708 ndmp2_data_start_backup_request* request2,
1709 ndmp9_data_start_backup_request* request9)
1710 {
1711 int n_error = 0;
1712
1713 CNVT_STRDUP_TO_9(request2, request9, bu_type);
1714
1715 ndmp_2to9_pval_vec_dup(request2->env.env_val, &request9->env.env_val,
1716 request2->env.env_len);
1717
1718 request9->env.env_len = request2->env.env_len;
1719
1720 n_error += ndmp_2to9_mover_addr(&request2->mover, &request9->addr);
1721
1722 return n_error;
1723 }
1724
ndmp_9to2_data_start_backup_request(ndmp9_data_start_backup_request * request9,ndmp2_data_start_backup_request * request2)1725 int ndmp_9to2_data_start_backup_request(
1726 ndmp9_data_start_backup_request* request9,
1727 ndmp2_data_start_backup_request* request2)
1728 {
1729 int n_error = 0;
1730
1731 CNVT_STRDUP_FROM_9(request2, request9, bu_type);
1732
1733 ndmp_9to2_pval_vec_dup(request9->env.env_val, &request2->env.env_val,
1734 request9->env.env_len);
1735
1736 request2->env.env_len = request9->env.env_len;
1737
1738 n_error += ndmp_9to2_mover_addr(&request9->addr, &request2->mover);
1739
1740 return n_error;
1741 }
1742
1743
1744 /*
1745 * ndmp_data_start_recover
1746 * ndmp_data_start_recover_filehist
1747 * just error reply
1748 */
1749
ndmp_2to9_data_start_recover_request(ndmp2_data_start_recover_request * request2,ndmp9_data_start_recover_request * request9)1750 int ndmp_2to9_data_start_recover_request(
1751 ndmp2_data_start_recover_request* request2,
1752 ndmp9_data_start_recover_request* request9)
1753 {
1754 int n_error = 0;
1755
1756 CNVT_STRDUP_TO_9(request2, request9, bu_type);
1757
1758 ndmp_2to9_pval_vec_dup(request2->env.env_val, &request9->env.env_val,
1759 request2->env.env_len);
1760
1761 request9->env.env_len = request2->env.env_len;
1762
1763 ndmp_2to9_name_vec_dup(request2->nlist.nlist_val, &request9->nlist.nlist_val,
1764 request2->nlist.nlist_len);
1765
1766 request9->nlist.nlist_len = request2->nlist.nlist_len;
1767
1768 n_error += ndmp_2to9_mover_addr(&request2->mover, &request9->addr);
1769
1770 return n_error;
1771 }
1772
ndmp_9to2_data_start_recover_request(ndmp9_data_start_recover_request * request9,ndmp2_data_start_recover_request * request2)1773 int ndmp_9to2_data_start_recover_request(
1774 ndmp9_data_start_recover_request* request9,
1775 ndmp2_data_start_recover_request* request2)
1776 {
1777 int n_error = 0;
1778
1779 CNVT_STRDUP_FROM_9(request2, request9, bu_type);
1780
1781 ndmp_9to2_pval_vec_dup(request9->env.env_val, &request2->env.env_val,
1782 request9->env.env_len);
1783
1784 request2->env.env_len = request9->env.env_len;
1785
1786 ndmp_9to2_name_vec_dup(request9->nlist.nlist_val, &request2->nlist.nlist_val,
1787 request9->nlist.nlist_len);
1788
1789 request2->nlist.nlist_len = request9->nlist.nlist_len;
1790
1791 n_error += ndmp_9to2_mover_addr(&request9->addr, &request2->mover);
1792
1793 return n_error;
1794 }
1795
1796
1797 /*
1798 * ndmp_data_abort
1799 * no args request, just error reply
1800 */
1801
1802 /*
1803 * ndmp_data_get_env
1804 * no args request
1805 */
1806
ndmp_2to9_data_get_env_reply(ndmp2_data_get_env_reply * reply2,ndmp9_data_get_env_reply * reply9)1807 int ndmp_2to9_data_get_env_reply(ndmp2_data_get_env_reply* reply2,
1808 ndmp9_data_get_env_reply* reply9)
1809 {
1810 CNVT_E_TO_9(reply2, reply9, error, ndmp_29_error);
1811
1812 ndmp_2to9_pval_vec_dup(reply2->env.env_val, &reply9->env.env_val,
1813 reply2->env.env_len);
1814
1815 reply9->env.env_len = reply2->env.env_len;
1816
1817 return 0;
1818 }
1819
ndmp_9to2_data_get_env_reply(ndmp9_data_get_env_reply * reply9,ndmp2_data_get_env_reply * reply2)1820 int ndmp_9to2_data_get_env_reply(ndmp9_data_get_env_reply* reply9,
1821 ndmp2_data_get_env_reply* reply2)
1822 {
1823 CNVT_E_FROM_9(reply2, reply9, error, ndmp_29_error);
1824
1825 ndmp_9to2_pval_vec_dup(reply9->env.env_val, &reply2->env.env_val,
1826 reply9->env.env_len);
1827
1828 reply2->env.env_len = reply9->env.env_len;
1829
1830 return 0;
1831 }
1832
1833
1834 /*
1835 * ndmp_data_stop
1836 * no args request, just error reply
1837 */
1838
1839
1840 /*
1841 * NOTIFY INTERFACES
1842 ****************************************************************
1843 */
1844
1845 /*
1846 * ndmp_notify_data_halted
1847 * just error reply
1848 */
1849
ndmp_2to9_notify_data_halted_request(ndmp2_notify_data_halted_request * request2,ndmp9_notify_data_halted_request * request9)1850 int ndmp_2to9_notify_data_halted_request(
1851 ndmp2_notify_data_halted_request* request2,
1852 ndmp9_notify_data_halted_request* request9)
1853 {
1854 int n_error = 0;
1855 int rc;
1856
1857 rc = CNVT_E_TO_9(request2, request9, reason, ndmp_29_data_halt_reason);
1858 if (rc == NDMP_INVALID_GENERAL) {
1859 CNVT_TO_9(request2, request9, reason);
1860 n_error++;
1861 }
1862
1863 return n_error;
1864 }
1865
ndmp_9to2_notify_data_halted_request(ndmp9_notify_data_halted_request * request9,ndmp2_notify_data_halted_request * request2)1866 int ndmp_9to2_notify_data_halted_request(
1867 ndmp9_notify_data_halted_request* request9,
1868 ndmp2_notify_data_halted_request* request2)
1869 {
1870 int n_error = 0;
1871 int rc;
1872
1873 rc = CNVT_E_FROM_9(request2, request9, reason, ndmp_29_data_halt_reason);
1874 if (rc == NDMP_INVALID_GENERAL) {
1875 CNVT_FROM_9(request2, request9, reason);
1876 n_error++;
1877 }
1878
1879 request2->text_reason = NDMOS_API_STRDUP("whatever");
1880
1881 return n_error;
1882 }
1883
1884
1885 /*
1886 * ndmp_notify_connected
1887 * just error reply
1888 */
1889
1890 /* NDMP2_NOTIFY_CONNECTED */
1891 struct enum_conversion ndmp_29_connect_reason[] = {
1892 {
1893 NDMP_INVALID_GENERAL,
1894 NDMP_INVALID_GENERAL,
1895 }, /* default */
1896 {NDMP2_CONNECTED, NDMP9_CONNECTED},
1897 {NDMP2_SHUTDOWN, NDMP9_SHUTDOWN},
1898 {NDMP2_REFUSED, NDMP9_REFUSED},
1899 END_ENUM_CONVERSION_TABLE};
1900
ndmp_2to9_notify_connected_request(ndmp2_notify_connected_request * request2,ndmp9_notify_connected_request * request9)1901 int ndmp_2to9_notify_connected_request(ndmp2_notify_connected_request* request2,
1902 ndmp9_notify_connected_request* request9)
1903 {
1904 int n_error = 0;
1905 int rc;
1906
1907 rc = CNVT_E_TO_9(request2, request9, reason, ndmp_29_connect_reason);
1908 if (rc == NDMP_INVALID_GENERAL) {
1909 CNVT_TO_9(request2, request9, reason);
1910 n_error++;
1911 }
1912
1913 CNVT_TO_9(request2, request9, protocol_version);
1914
1915 CNVT_STRDUP_TO_9(request2, request9, text_reason);
1916
1917 return n_error;
1918 }
1919
ndmp_9to2_notify_connected_request(ndmp9_notify_connected_request * request9,ndmp2_notify_connected_request * request2)1920 int ndmp_9to2_notify_connected_request(ndmp9_notify_connected_request* request9,
1921 ndmp2_notify_connected_request* request2)
1922 {
1923 int n_error = 0;
1924 int rc;
1925
1926 rc = CNVT_E_FROM_9(request2, request9, reason, ndmp_29_connect_reason);
1927 if (rc == NDMP_INVALID_GENERAL) {
1928 CNVT_FROM_9(request2, request9, reason);
1929 n_error++;
1930 }
1931
1932 CNVT_FROM_9(request2, request9, protocol_version);
1933
1934 CNVT_STRDUP_FROM_9(request2, request9, text_reason);
1935
1936 return n_error;
1937 }
1938
1939
1940 /*
1941 * ndmp_notify_mover_halted
1942 * just error reply
1943 */
1944
ndmp_2to9_notify_mover_halted_request(ndmp2_notify_mover_halted_request * request2,ndmp9_notify_mover_halted_request * request9)1945 int ndmp_2to9_notify_mover_halted_request(
1946 ndmp2_notify_mover_halted_request* request2,
1947 ndmp9_notify_mover_halted_request* request9)
1948 {
1949 int n_error = 0;
1950 int rc;
1951
1952 rc = CNVT_E_TO_9(request2, request9, reason, ndmp_29_mover_halt_reason);
1953 if (rc == NDMP_INVALID_GENERAL) {
1954 CNVT_TO_9(request2, request9, reason);
1955 n_error++;
1956 }
1957
1958 return n_error;
1959 }
1960
ndmp_9to2_notify_mover_halted_request(ndmp9_notify_mover_halted_request * request9,ndmp2_notify_mover_halted_request * request2)1961 int ndmp_9to2_notify_mover_halted_request(
1962 ndmp9_notify_mover_halted_request* request9,
1963 ndmp2_notify_mover_halted_request* request2)
1964 {
1965 int n_error = 0;
1966 int rc;
1967
1968 rc = CNVT_E_FROM_9(request2, request9, reason, ndmp_29_mover_halt_reason);
1969 if (rc == NDMP_INVALID_GENERAL) {
1970 CNVT_FROM_9(request2, request9, reason);
1971 n_error++;
1972 }
1973
1974 request2->text_reason = NDMOS_API_STRDUP("Whatever");
1975
1976 return n_error;
1977 }
1978
1979
1980 /*
1981 * ndmp_notify_mover_paused
1982 * just error reply
1983 */
1984
ndmp_2to9_notify_mover_paused_request(ndmp2_notify_mover_paused_request * request2,ndmp9_notify_mover_paused_request * request9)1985 int ndmp_2to9_notify_mover_paused_request(
1986 ndmp2_notify_mover_paused_request* request2,
1987 ndmp9_notify_mover_paused_request* request9)
1988 {
1989 int n_error = 0;
1990 int rc;
1991
1992 rc = CNVT_E_TO_9(request2, request9, reason, ndmp_29_mover_pause_reason);
1993 if (rc == NDMP_INVALID_GENERAL) {
1994 CNVT_TO_9(request2, request9, reason);
1995 n_error++;
1996 }
1997
1998 CNVT_TO_9(request2, request9, seek_position);
1999
2000 return n_error;
2001 }
2002
ndmp_9to2_notify_mover_paused_request(ndmp9_notify_mover_paused_request * request9,ndmp2_notify_mover_paused_request * request2)2003 int ndmp_9to2_notify_mover_paused_request(
2004 ndmp9_notify_mover_paused_request* request9,
2005 ndmp2_notify_mover_paused_request* request2)
2006 {
2007 int n_error = 0;
2008 int rc;
2009
2010 rc = CNVT_E_FROM_9(request2, request9, reason, ndmp_29_mover_pause_reason);
2011 if (rc == NDMP_INVALID_GENERAL) {
2012 CNVT_FROM_9(request2, request9, reason);
2013 n_error++;
2014 }
2015
2016 CNVT_FROM_9(request2, request9, seek_position);
2017
2018 return n_error;
2019 }
2020
2021
2022 /*
2023 * ndmp_notify_data_read
2024 * just error reply
2025 */
2026
ndmp_2to9_notify_data_read_request(ndmp2_notify_data_read_request * request2,ndmp9_notify_data_read_request * request9)2027 int ndmp_2to9_notify_data_read_request(ndmp2_notify_data_read_request* request2,
2028 ndmp9_notify_data_read_request* request9)
2029 {
2030 CNVT_TO_9(request2, request9, offset);
2031 CNVT_TO_9(request2, request9, length);
2032 return 0;
2033 }
2034
ndmp_9to2_notify_data_read_request(ndmp9_notify_data_read_request * request9,ndmp2_notify_data_read_request * request2)2035 int ndmp_9to2_notify_data_read_request(ndmp9_notify_data_read_request* request9,
2036 ndmp2_notify_data_read_request* request2)
2037 {
2038 CNVT_FROM_9(request2, request9, offset);
2039 CNVT_FROM_9(request2, request9, length);
2040 return 0;
2041 }
2042
2043
2044 /*
2045 * LOG INTERFACES
2046 ****************************************************************
2047 */
2048
2049 /*
2050 * ndmp2_log_log and ndmp2_log_debug are not handled
2051 * by the ndmp9 translater. Like ndmp2_config_get_butype_attr,
2052 * these NDMP2 log interfaces do not pair well with the
2053 * ndmp[349] interfaces. So they are handled directly
2054 * rather than by translation.
2055 */
2056
2057 struct enum_conversion ndmp_29_recovery_status[] = {
2058 {NDMP2_UNDEFINED_ERR, NDMP9_RECOVERY_FAILED_UNDEFINED_ERROR}, /* default */
2059 {NDMP2_NO_ERR, NDMP9_RECOVERY_SUCCESSFUL},
2060 {NDMP2_PERMISSION_ERR, NDMP9_RECOVERY_FAILED_PERMISSION},
2061 {NDMP2_FILE_NOT_FOUND_ERR, NDMP9_RECOVERY_FAILED_NOT_FOUND},
2062 {NDMP2_BAD_FILE_ERR, NDMP9_RECOVERY_FAILED_NO_DIRECTORY},
2063 {NDMP2_NO_MEM_ERR, NDMP9_RECOVERY_FAILED_OUT_OF_MEMORY},
2064 {NDMP2_IO_ERR, NDMP9_RECOVERY_FAILED_IO_ERROR},
2065 {NDMP2_UNDEFINED_ERR, NDMP9_RECOVERY_FAILED_UNDEFINED_ERROR},
2066 END_ENUM_CONVERSION_TABLE};
2067
2068
ndmp_2to9_log_file_request(ndmp2_log_file_request * request2,ndmp9_log_file_request * request9)2069 int ndmp_2to9_log_file_request(ndmp2_log_file_request* request2,
2070 ndmp9_log_file_request* request9)
2071 {
2072 request9->recovery_status =
2073 convert_enum_to_9(ndmp_29_recovery_status, request2->error);
2074 CNVT_STRDUP_TO_9(request2, request9, name);
2075 return 0;
2076 }
2077
ndmp_9to2_log_file_request(ndmp9_log_file_request * request9,ndmp2_log_file_request * request2)2078 int ndmp_9to2_log_file_request(ndmp9_log_file_request* request9,
2079 ndmp2_log_file_request* request2)
2080 {
2081 request2->error =
2082 convert_enum_from_9(ndmp_29_recovery_status, request9->recovery_status);
2083 CNVT_STRDUP_FROM_9(request2, request9, name);
2084 return 0;
2085 }
2086
2087
2088 /*
2089 * FILE HISTORY INTERFACES
2090 ****************************************************************
2091 */
2092
2093 /*
2094 * ndmp[_unix]_file_stat
2095 */
2096
2097 struct enum_conversion ndmp_29_file_type[] = {
2098 {
2099 NDMP_INVALID_GENERAL,
2100 NDMP_INVALID_GENERAL,
2101 }, /* default */
2102 {NDMP2_FILE_DIR, NDMP9_FILE_DIR},
2103 {NDMP2_FILE_FIFO, NDMP9_FILE_FIFO},
2104 {NDMP2_FILE_CSPEC, NDMP9_FILE_CSPEC},
2105 {NDMP2_FILE_BSPEC, NDMP9_FILE_BSPEC},
2106 {NDMP2_FILE_REG, NDMP9_FILE_REG},
2107 {NDMP2_FILE_SLINK, NDMP9_FILE_SLINK},
2108 {NDMP2_FILE_SOCK, NDMP9_FILE_SOCK},
2109 END_ENUM_CONVERSION_TABLE};
2110
2111
ndmp_2to9_unix_file_stat(ndmp2_unix_file_stat * fstat2,ndmp9_file_stat * fstat9)2112 int ndmp_2to9_unix_file_stat(ndmp2_unix_file_stat* fstat2,
2113 ndmp9_file_stat* fstat9)
2114 {
2115 CNVT_E_TO_9(fstat2, fstat9, ftype, ndmp_29_file_type);
2116
2117 CNVT_VUL_TO_9(fstat2, fstat9, mtime);
2118 CNVT_VUL_TO_9(fstat2, fstat9, atime);
2119 CNVT_VUL_TO_9(fstat2, fstat9, ctime);
2120 CNVT_VUL_TO_9(fstat2, fstat9, uid);
2121 CNVT_VUL_TO_9(fstat2, fstat9, gid);
2122
2123 CNVT_VUL_TO_9(fstat2, fstat9, mode);
2124
2125 CNVT_VUQ_TO_9(fstat2, fstat9, size);
2126 CNVT_VUQ_TO_9(fstat2, fstat9, fh_info);
2127
2128 return 0;
2129 }
2130
ndmp_9to2_unix_file_stat(ndmp9_file_stat * fstat9,ndmp2_unix_file_stat * fstat2)2131 int ndmp_9to2_unix_file_stat(ndmp9_file_stat* fstat9,
2132 ndmp2_unix_file_stat* fstat2)
2133 {
2134 CNVT_E_FROM_9(fstat2, fstat9, ftype, ndmp_29_file_type);
2135
2136 CNVT_VUL_FROM_9(fstat2, fstat9, mtime);
2137 CNVT_VUL_FROM_9(fstat2, fstat9, atime);
2138 CNVT_VUL_FROM_9(fstat2, fstat9, ctime);
2139 CNVT_VUL_FROM_9(fstat2, fstat9, uid);
2140 CNVT_VUL_FROM_9(fstat2, fstat9, gid);
2141
2142 CNVT_VUL_FROM_9(fstat2, fstat9, mode);
2143
2144 CNVT_VUQ_FROM_9(fstat2, fstat9, size);
2145 CNVT_VUQ_FROM_9(fstat2, fstat9, fh_info);
2146
2147 /* node ignored */
2148
2149 return 0;
2150 }
2151
2152
2153 /*
2154 * ndmp_fh_add_unix_path_request
2155 */
2156
ndmp_2to9_fh_add_unix_path_request(ndmp2_fh_add_unix_path_request * request2,ndmp9_fh_add_file_request * request9)2157 int ndmp_2to9_fh_add_unix_path_request(ndmp2_fh_add_unix_path_request* request2,
2158 ndmp9_fh_add_file_request* request9)
2159 {
2160 int n_ent = request2->paths.paths_len;
2161 int i;
2162 ndmp9_file* table;
2163
2164 table = NDMOS_MACRO_NEWN(ndmp9_file, n_ent);
2165 if (!table) return -1;
2166
2167 NDMOS_API_BZERO(table, sizeof *table * n_ent);
2168
2169 for (i = 0; i < n_ent; i++) {
2170 ndmp2_fh_unix_path* ent2 = &request2->paths.paths_val[i];
2171 ndmp9_file* ent9 = &table[i];
2172
2173 CNVT_STRDUP_TO_9x(ent2, ent9, name, unix_path);
2174 ndmp_2to9_unix_file_stat(&ent2->fstat, &ent9->fstat);
2175 }
2176
2177 request9->files.files_len = n_ent;
2178 request9->files.files_val = table;
2179
2180 return 0;
2181 }
2182
ndmp_9to2_fh_add_unix_path_request(ndmp9_fh_add_file_request * request9,ndmp2_fh_add_unix_path_request * request2)2183 int ndmp_9to2_fh_add_unix_path_request(ndmp9_fh_add_file_request* request9,
2184 ndmp2_fh_add_unix_path_request* request2)
2185 {
2186 int n_ent = request9->files.files_len;
2187 int i;
2188 ndmp2_fh_unix_path* table;
2189
2190 table = NDMOS_MACRO_NEWN(ndmp2_fh_unix_path, n_ent);
2191 if (!table) return -1;
2192
2193 NDMOS_API_BZERO(table, sizeof *table * n_ent);
2194
2195 for (i = 0; i < n_ent; i++) {
2196 ndmp2_fh_unix_path* ent2 = &table[i];
2197 ndmp9_file* ent9 = &request9->files.files_val[i];
2198
2199 CNVT_STRDUP_FROM_9x(ent2, ent9, name, unix_path);
2200 ndmp_9to2_unix_file_stat(&ent9->fstat, &ent2->fstat);
2201 }
2202
2203 request2->paths.paths_len = n_ent;
2204 request2->paths.paths_val = table;
2205
2206 return 0;
2207 }
2208
2209
2210 /*
2211 * ndmp_fh_add_unix_dir
2212 */
2213
ndmp_2to9_fh_add_unix_dir_request(ndmp2_fh_add_unix_dir_request * request2,ndmp9_fh_add_dir_request * request9)2214 int ndmp_2to9_fh_add_unix_dir_request(ndmp2_fh_add_unix_dir_request* request2,
2215 ndmp9_fh_add_dir_request* request9)
2216 {
2217 int n_ent = request2->dirs.dirs_len;
2218 int i;
2219 ndmp9_dir* table;
2220
2221 table = NDMOS_MACRO_NEWN(ndmp9_dir, n_ent);
2222 if (!table) return -1;
2223
2224 NDMOS_API_BZERO(table, sizeof *table * n_ent);
2225
2226 for (i = 0; i < n_ent; i++) {
2227 ndmp2_fh_unix_dir* ent2 = &request2->dirs.dirs_val[i];
2228 ndmp9_dir* ent9 = &table[i];
2229
2230 CNVT_STRDUP_TO_9x(ent2, ent9, name, unix_name);
2231 CNVT_TO_9(ent2, ent9, node);
2232 CNVT_TO_9(ent2, ent9, parent);
2233 }
2234
2235 request9->dirs.dirs_len = n_ent;
2236 request9->dirs.dirs_val = table;
2237
2238 return 0;
2239 }
2240
ndmp_2to9_fh_add_unix_dir_free_request(ndmp9_fh_add_dir_request * request9)2241 int ndmp_2to9_fh_add_unix_dir_free_request(ndmp9_fh_add_dir_request* request9)
2242 {
2243 int i;
2244
2245 if (request9) {
2246 if (request9->dirs.dirs_val) {
2247 int n_ent = request9->dirs.dirs_len;
2248
2249 for (i = 0; i < n_ent; i++) {
2250 ndmp9_dir* ent9 = &request9->dirs.dirs_val[i];
2251 if (ent9->unix_name) NDMOS_API_FREE(ent9->unix_name);
2252 ent9->unix_name = 0;
2253 }
2254
2255 NDMOS_API_FREE(request9->dirs.dirs_val);
2256 }
2257 request9->dirs.dirs_val = 0;
2258 }
2259 return 0;
2260 }
2261
ndmp_9to2_fh_add_unix_dir_request(ndmp9_fh_add_dir_request * request9,ndmp2_fh_add_unix_dir_request * request2)2262 int ndmp_9to2_fh_add_unix_dir_request(ndmp9_fh_add_dir_request* request9,
2263 ndmp2_fh_add_unix_dir_request* request2)
2264 {
2265 int n_ent = request9->dirs.dirs_len;
2266 int i;
2267 ndmp2_fh_unix_dir* table;
2268
2269 table = NDMOS_MACRO_NEWN(ndmp2_fh_unix_dir, n_ent);
2270 if (!table) return -1;
2271
2272 NDMOS_API_BZERO(table, sizeof *table * n_ent);
2273
2274 for (i = 0; i < n_ent; i++) {
2275 ndmp9_dir* ent9 = &request9->dirs.dirs_val[i];
2276 ndmp2_fh_unix_dir* ent2 = &table[i];
2277
2278 CNVT_STRDUP_FROM_9x(ent2, ent9, name, unix_name);
2279 CNVT_FROM_9(ent2, ent9, node);
2280 CNVT_FROM_9(ent2, ent9, parent);
2281 }
2282
2283 request2->dirs.dirs_len = n_ent;
2284 request2->dirs.dirs_val = table;
2285
2286 return 0;
2287 }
2288
ndmp_9to2_fh_add_unix_dir_free_request(ndmp2_fh_add_unix_dir_request * request2)2289 int ndmp_9to2_fh_add_unix_dir_free_request(
2290 ndmp2_fh_add_unix_dir_request* request2)
2291 {
2292 int i;
2293
2294 if (request2) {
2295 if (request2->dirs.dirs_val) {
2296 int n_ent = request2->dirs.dirs_len;
2297
2298 for (i = 0; i < n_ent; i++) {
2299 ndmp2_fh_unix_dir* ent2 = &request2->dirs.dirs_val[i];
2300
2301 if (ent2->name) NDMOS_API_FREE(ent2->name);
2302 ent2->name = 0;
2303 }
2304
2305 NDMOS_API_FREE(request2->dirs.dirs_val);
2306 }
2307 request2->dirs.dirs_val = 0;
2308 }
2309
2310 return 0;
2311 }
2312
2313
2314 /*
2315 * ndmp_fh_add_unix_node
2316 */
2317
ndmp_2to9_fh_add_unix_node_request(ndmp2_fh_add_unix_node_request * request2,ndmp9_fh_add_node_request * request9)2318 int ndmp_2to9_fh_add_unix_node_request(ndmp2_fh_add_unix_node_request* request2,
2319 ndmp9_fh_add_node_request* request9)
2320 {
2321 int n_ent = request2->nodes.nodes_len;
2322 int i;
2323 ndmp9_node* table;
2324
2325 table = NDMOS_MACRO_NEWN(ndmp9_node, n_ent);
2326 if (!table) return -1;
2327
2328 NDMOS_API_BZERO(table, sizeof *table * n_ent);
2329
2330 for (i = 0; i < n_ent; i++) {
2331 ndmp2_fh_unix_node* ent2 = &request2->nodes.nodes_val[i];
2332 ndmp9_node* ent9 = &table[i];
2333
2334 ndmp_2to9_unix_file_stat(&ent2->fstat, &ent9->fstat);
2335 ent9->fstat.node.valid = NDMP9_VALIDITY_VALID;
2336 ent9->fstat.node.value = ent2->node;
2337 }
2338
2339 request9->nodes.nodes_len = n_ent;
2340 request9->nodes.nodes_val = table;
2341
2342 return 0;
2343 }
2344
ndmp_2to9_fh_add_unix_node_free_request(ndmp9_fh_add_node_request * request9)2345 int ndmp_2to9_fh_add_unix_node_free_request(ndmp9_fh_add_node_request* request9)
2346 {
2347 if (request9) {
2348 if (request9->nodes.nodes_val) {
2349 NDMOS_API_FREE(request9->nodes.nodes_val);
2350 }
2351 request9->nodes.nodes_val = 0;
2352 }
2353 return 0;
2354 }
2355
ndmp_9to2_fh_add_unix_node_request(ndmp9_fh_add_node_request * request9,ndmp2_fh_add_unix_node_request * request2)2356 int ndmp_9to2_fh_add_unix_node_request(ndmp9_fh_add_node_request* request9,
2357 ndmp2_fh_add_unix_node_request* request2)
2358 {
2359 int n_ent = request9->nodes.nodes_len;
2360 int i;
2361 ndmp2_fh_unix_node* table;
2362
2363 table = NDMOS_MACRO_NEWN(ndmp2_fh_unix_node, n_ent);
2364 if (!table) return -1;
2365
2366 NDMOS_API_BZERO(table, sizeof *table * n_ent);
2367
2368 for (i = 0; i < n_ent; i++) {
2369 ndmp9_node* ent9 = &request9->nodes.nodes_val[i];
2370 ndmp2_fh_unix_node* ent2 = &table[i];
2371
2372 ndmp_9to2_unix_file_stat(&ent9->fstat, &ent2->fstat);
2373 ent2->node = ent9->fstat.node.value;
2374 }
2375
2376 request2->nodes.nodes_len = n_ent;
2377 request2->nodes.nodes_val = table;
2378
2379 return 0;
2380 }
2381
ndmp_9to2_fh_add_unix_node_free_request(ndmp2_fh_add_unix_node_request * request2)2382 int ndmp_9to2_fh_add_unix_node_free_request(
2383 ndmp2_fh_add_unix_node_request* request2)
2384 {
2385 if (request2) {
2386 if (request2->nodes.nodes_val) {
2387 NDMOS_API_FREE(request2->nodes.nodes_val);
2388 }
2389 request2->nodes.nodes_val = 0;
2390 }
2391 return 0;
2392 }
2393
2394
2395 /*
2396 * request/reply translation
2397 */
2398
2399 #define NO_ARG_REQUEST ndmp_xtox_no_arguments, ndmp_xtox_no_arguments
2400
2401 #define JUST_ERROR_REPLY ndmp_2to9_error, ndmp_9to2_error
2402
2403 #define NO_ARG_REQUEST_JUST_ERROR_REPLY NO_ARG_REQUEST, JUST_ERROR_REPLY
2404
2405 #define NO_MEMUSED_REQUEST ndmp_xtox_no_memused, ndmp_xtox_no_memused
2406
2407 #define NO_MEMUSED_REPLY ndmp_xtox_no_memused, ndmp_xtox_no_memused
2408
2409 #define NO_MEMUSED \
2410 ndmp_xtox_no_memused, ndmp_xtox_no_memused, ndmp_xtox_no_memused, \
2411 ndmp_xtox_no_memused
2412
2413
2414 struct reqrep_xlate ndmp2_reqrep_xlate_table[] = {
2415 {
2416 NDMP2_CONNECT_OPEN, NDMP9_CONNECT_OPEN, ndmp_2to9_connect_open_request,
2417 ndmp_9to2_connect_open_request, JUST_ERROR_REPLY,
2418 NO_MEMUSED /* no memory free routines written yet */
2419 },
2420 {
2421 NDMP2_CONNECT_CLIENT_AUTH, NDMP9_CONNECT_CLIENT_AUTH,
2422 ndmp_2to9_connect_client_auth_request,
2423 ndmp_9to2_connect_client_auth_request, JUST_ERROR_REPLY,
2424 NO_MEMUSED /* no memory free routines written yet */
2425 },
2426 {
2427 NDMP2_CONNECT_CLOSE, NDMP9_CONNECT_CLOSE,
2428 NO_ARG_REQUEST_JUST_ERROR_REPLY, /* actually no reply */
2429 NO_MEMUSED /* no memory free routines written yet */
2430 },
2431 #ifdef notyet
2432 {
2433 NDMP2_CONNECT_SERVER_AUTH, NDMP9_CONNECT_SERVER_AUTH,
2434 ndmp_2to9_connect_server_auth_request,
2435 ndmp_9to2_connect_server_auth_request,
2436 ndmp_2to9_connect_server_auth_reply,
2437 ndmp_9to2_connect_server_auth_reply,
2438 NO_MEMUSED /* no memory free routines written yet */
2439 },
2440 #endif /* notyet */
2441 {
2442 NDMP2_CONFIG_GET_HOST_INFO, NDMP9_CONFIG_GET_HOST_INFO, NO_ARG_REQUEST,
2443 ndmp_2to9_config_get_host_info_reply,
2444 ndmp_9to2_config_get_host_info_reply,
2445 NO_MEMUSED /* no memory free routines written yet */
2446 },
2447 /*
2448 * ndmp2_config_get_butype_attr handled
2449 * as version specific dispatch function
2450 * in ndma_comm_dispatch.c
2451 */
2452 {
2453 NDMP2_CONFIG_GET_MOVER_TYPE, NDMP9_CONFIG_GET_CONNECTION_TYPE,
2454 NO_ARG_REQUEST, ndmp_2to9_config_get_mover_type_reply,
2455 ndmp_9to2_config_get_mover_type_reply,
2456 NO_MEMUSED /* no memory free routines written yet */
2457 },
2458 {
2459 NDMP2_CONFIG_GET_AUTH_ATTR, NDMP9_CONFIG_GET_AUTH_ATTR,
2460 ndmp_2to9_config_get_auth_attr_request,
2461 ndmp_9to2_config_get_auth_attr_request,
2462 ndmp_2to9_config_get_auth_attr_reply,
2463 ndmp_9to2_config_get_auth_attr_reply,
2464 NO_MEMUSED /* no memory free routines written yet */
2465 },
2466
2467 {
2468 NDMP2_SCSI_OPEN, NDMP9_SCSI_OPEN, ndmp_2to9_scsi_open_request,
2469 ndmp_9to2_scsi_open_request, JUST_ERROR_REPLY,
2470 NO_MEMUSED /* no memory free routines written yet */
2471 },
2472 {
2473 NDMP2_SCSI_CLOSE, NDMP9_SCSI_CLOSE, NO_ARG_REQUEST_JUST_ERROR_REPLY,
2474 NO_MEMUSED /* no memory free routines written yet */
2475 },
2476 {
2477 NDMP2_SCSI_GET_STATE, NDMP9_SCSI_GET_STATE, NO_ARG_REQUEST,
2478 ndmp_2to9_scsi_get_state_reply, ndmp_9to2_scsi_get_state_reply,
2479 NO_MEMUSED /* no memory free routines written yet */
2480 },
2481 {
2482 NDMP2_SCSI_SET_TARGET, NDMP9_SCSI_SET_TARGET,
2483 ndmp_2to9_scsi_set_target_request, ndmp_9to2_scsi_set_target_request,
2484 JUST_ERROR_REPLY, NO_MEMUSED /* no memory free routines written yet */
2485 },
2486 {
2487 NDMP2_SCSI_RESET_DEVICE, NDMP9_SCSI_RESET_DEVICE,
2488 NO_ARG_REQUEST_JUST_ERROR_REPLY,
2489 NO_MEMUSED /* no memory free routines written yet */
2490 },
2491 {
2492 NDMP2_SCSI_RESET_BUS, NDMP9_SCSI_RESET_BUS,
2493 NO_ARG_REQUEST_JUST_ERROR_REPLY,
2494 NO_MEMUSED /* no memory free routines written yet */
2495 },
2496 {
2497 NDMP2_SCSI_EXECUTE_CDB, NDMP9_SCSI_EXECUTE_CDB,
2498 ndmp_2to9_execute_cdb_request, ndmp_9to2_execute_cdb_request,
2499 ndmp_2to9_execute_cdb_reply, ndmp_9to2_execute_cdb_reply,
2500 NO_MEMUSED /* no memory free routines written yet */
2501 },
2502
2503
2504 {
2505 NDMP2_TAPE_OPEN, NDMP9_TAPE_OPEN, ndmp_2to9_tape_open_request,
2506 ndmp_9to2_tape_open_request, JUST_ERROR_REPLY,
2507 NO_MEMUSED /* no memory free routines written yet */
2508 },
2509 {
2510 NDMP2_TAPE_CLOSE, NDMP9_TAPE_CLOSE, NO_ARG_REQUEST_JUST_ERROR_REPLY,
2511 NO_MEMUSED /* no memory free routines written yet */
2512 },
2513 {
2514 NDMP2_TAPE_GET_STATE, NDMP9_TAPE_GET_STATE, NO_ARG_REQUEST,
2515 ndmp_2to9_tape_get_state_reply, ndmp_9to2_tape_get_state_reply,
2516 NO_MEMUSED /* no memory free routines written yet */
2517 },
2518 {
2519 NDMP2_TAPE_MTIO, NDMP9_TAPE_MTIO, ndmp_2to9_tape_mtio_request,
2520 ndmp_9to2_tape_mtio_request, ndmp_2to9_tape_mtio_reply,
2521 ndmp_9to2_tape_mtio_reply,
2522 NO_MEMUSED /* no memory free routines written yet */
2523 },
2524 {
2525 NDMP2_TAPE_WRITE, NDMP9_TAPE_WRITE, ndmp_2to9_tape_write_request,
2526 ndmp_9to2_tape_write_request, ndmp_2to9_tape_write_reply,
2527 ndmp_9to2_tape_write_reply,
2528 NO_MEMUSED /* no memory free routines written yet */
2529 },
2530 {
2531 NDMP2_TAPE_READ, NDMP9_TAPE_READ, ndmp_2to9_tape_read_request,
2532 ndmp_9to2_tape_read_request, ndmp_2to9_tape_read_reply,
2533 ndmp_9to2_tape_read_reply,
2534 NO_MEMUSED /* no memory free routines written yet */
2535 },
2536 {
2537 NDMP2_TAPE_EXECUTE_CDB, NDMP9_TAPE_EXECUTE_CDB,
2538 ndmp_2to9_execute_cdb_request, ndmp_9to2_execute_cdb_request,
2539 ndmp_2to9_execute_cdb_reply, ndmp_9to2_execute_cdb_reply,
2540 NO_MEMUSED /* no memory free routines written yet */
2541 },
2542
2543 {
2544 NDMP2_DATA_GET_STATE, NDMP9_DATA_GET_STATE, NO_ARG_REQUEST,
2545 ndmp_2to9_data_get_state_reply, ndmp_9to2_data_get_state_reply,
2546 NO_MEMUSED /* no memory free routines written yet */
2547 },
2548 {
2549 NDMP2_DATA_START_BACKUP, NDMP9_DATA_START_BACKUP,
2550 ndmp_2to9_data_start_backup_request,
2551 ndmp_9to2_data_start_backup_request, JUST_ERROR_REPLY,
2552 NO_MEMUSED /* no memory free routines written yet */
2553 },
2554 {
2555 NDMP2_DATA_START_RECOVER, NDMP9_DATA_START_RECOVER,
2556 ndmp_2to9_data_start_recover_request,
2557 ndmp_9to2_data_start_recover_request, JUST_ERROR_REPLY,
2558 NO_MEMUSED /* no memory free routines written yet */
2559 },
2560 {
2561 NDMP2_DATA_ABORT, NDMP9_DATA_ABORT, NO_ARG_REQUEST_JUST_ERROR_REPLY,
2562 NO_MEMUSED /* no memory free routines written yet */
2563 },
2564 {
2565 NDMP2_DATA_GET_ENV, NDMP9_DATA_GET_ENV, NO_ARG_REQUEST,
2566 ndmp_2to9_data_get_env_reply, ndmp_9to2_data_get_env_reply,
2567 NO_MEMUSED /* no memory free routines written yet */
2568 },
2569 {
2570 NDMP2_DATA_STOP, NDMP9_DATA_STOP, NO_ARG_REQUEST_JUST_ERROR_REPLY,
2571 NO_MEMUSED /* no memory free routines written yet */
2572 },
2573 {
2574 NDMP2_DATA_START_RECOVER_FILEHIST, NDMP9_DATA_START_RECOVER_FILEHIST,
2575 ndmp_2to9_data_start_recover_request,
2576 ndmp_9to2_data_start_recover_request, JUST_ERROR_REPLY,
2577 NO_MEMUSED /* no memory free routines written yet */
2578 },
2579
2580 {
2581 NDMP2_NOTIFY_DATA_HALTED, NDMP9_NOTIFY_DATA_HALTED,
2582 ndmp_2to9_notify_data_halted_request,
2583 ndmp_9to2_notify_data_halted_request,
2584 JUST_ERROR_REPLY, /* no reply actually */
2585 NO_MEMUSED /* no memory free routines written yet */
2586 },
2587 {
2588 NDMP2_NOTIFY_CONNECTED, NDMP9_NOTIFY_CONNECTED,
2589 ndmp_2to9_notify_connected_request, ndmp_9to2_notify_connected_request,
2590 JUST_ERROR_REPLY, /* no reply actually */
2591 NO_MEMUSED /* no memory free routines written yet */
2592 },
2593 {
2594 NDMP2_NOTIFY_MOVER_HALTED, NDMP9_NOTIFY_MOVER_HALTED,
2595 ndmp_2to9_notify_mover_halted_request,
2596 ndmp_9to2_notify_mover_halted_request,
2597 JUST_ERROR_REPLY, /* no reply actually */
2598 NO_MEMUSED /* no memory free routines written yet */
2599 },
2600 {
2601 NDMP2_NOTIFY_MOVER_PAUSED, NDMP9_NOTIFY_MOVER_PAUSED,
2602 ndmp_2to9_notify_mover_paused_request,
2603 ndmp_9to2_notify_mover_paused_request,
2604 JUST_ERROR_REPLY, /* no reply actually */
2605 NO_MEMUSED /* no memory free routines written yet */
2606 },
2607 {
2608 NDMP2_NOTIFY_DATA_READ, NDMP9_NOTIFY_DATA_READ,
2609 ndmp_2to9_notify_data_read_request, ndmp_9to2_notify_data_read_request,
2610 JUST_ERROR_REPLY, /* no reply actually */
2611 NO_MEMUSED /* no memory free routines written yet */
2612 },
2613
2614 {
2615 NDMP2_LOG_FILE, NDMP9_LOG_FILE, ndmp_2to9_log_file_request,
2616 ndmp_9to2_log_file_request, JUST_ERROR_REPLY, /* no reply actually */
2617 NO_MEMUSED /* no memory free routines written yet */
2618 },
2619
2620 {
2621 NDMP2_FH_ADD_UNIX_PATH, NDMP9_FH_ADD_FILE,
2622 ndmp_2to9_fh_add_unix_path_request, ndmp_9to2_fh_add_unix_path_request,
2623 JUST_ERROR_REPLY, /* no reply actually */
2624 NO_MEMUSED /* no memory free routines written yet */
2625 },
2626 {NDMP2_FH_ADD_UNIX_DIR, NDMP9_FH_ADD_DIR, ndmp_2to9_fh_add_unix_dir_request,
2627 ndmp_9to2_fh_add_unix_dir_request,
2628 JUST_ERROR_REPLY, /* no reply actually */
2629 ndmp_2to9_fh_add_unix_dir_free_request,
2630 ndmp_9to2_fh_add_unix_dir_free_request, NO_MEMUSED_REPLY},
2631 {NDMP2_FH_ADD_UNIX_NODE, NDMP9_FH_ADD_NODE,
2632 ndmp_2to9_fh_add_unix_node_request, ndmp_9to2_fh_add_unix_node_request,
2633 JUST_ERROR_REPLY, /* no reply actually */
2634 ndmp_2to9_fh_add_unix_node_free_request,
2635 ndmp_9to2_fh_add_unix_node_free_request, NO_MEMUSED_REPLY},
2636
2637 {
2638 NDMP2_MOVER_GET_STATE, NDMP9_MOVER_GET_STATE, NO_ARG_REQUEST,
2639 ndmp_2to9_mover_get_state_reply, ndmp_9to2_mover_get_state_reply,
2640 NO_MEMUSED /* no memory free routines written yet */
2641 },
2642 {
2643 NDMP2_MOVER_LISTEN, NDMP9_MOVER_LISTEN, ndmp_2to9_mover_listen_request,
2644 ndmp_9to2_mover_listen_request, ndmp_2to9_mover_listen_reply,
2645 ndmp_9to2_mover_listen_reply,
2646 NO_MEMUSED /* no memory free routines written yet */
2647 },
2648 {
2649 NDMP2_MOVER_SET_RECORD_SIZE, NDMP9_MOVER_SET_RECORD_SIZE,
2650 ndmp_2to9_mover_set_record_size_request,
2651 ndmp_9to2_mover_set_record_size_request, JUST_ERROR_REPLY,
2652 NO_MEMUSED /* no memory free routines written yet */
2653 },
2654 {
2655 NDMP2_MOVER_SET_WINDOW, NDMP9_MOVER_SET_WINDOW,
2656 ndmp_2to9_mover_set_window_request, ndmp_9to2_mover_set_window_request,
2657 JUST_ERROR_REPLY, NO_MEMUSED /* no memory free routines written yet */
2658 },
2659 {
2660 NDMP2_MOVER_CONTINUE, NDMP9_MOVER_CONTINUE,
2661 NO_ARG_REQUEST_JUST_ERROR_REPLY,
2662 NO_MEMUSED /* no memory free routines written yet */
2663 },
2664 {
2665 NDMP2_MOVER_ABORT, NDMP9_MOVER_ABORT, NO_ARG_REQUEST_JUST_ERROR_REPLY,
2666 NO_MEMUSED /* no memory free routines written yet */
2667 },
2668 {
2669 NDMP2_MOVER_STOP, NDMP9_MOVER_STOP, NO_ARG_REQUEST_JUST_ERROR_REPLY,
2670 NO_MEMUSED /* no memory free routines written yet */
2671 },
2672 {
2673 NDMP2_MOVER_READ, NDMP9_MOVER_READ, ndmp_2to9_mover_read_request,
2674 ndmp_9to2_mover_read_request, JUST_ERROR_REPLY,
2675 NO_MEMUSED /* no memory free routines written yet */
2676 },
2677 {
2678 NDMP2_MOVER_CLOSE, NDMP9_MOVER_CLOSE, NO_ARG_REQUEST_JUST_ERROR_REPLY,
2679 NO_MEMUSED /* no memory free routines written yet */
2680 },
2681
2682 {0},
2683 };
2684
2685
2686 #endif /* !NDMOS_OPTION_NO_NDMP2 */
2687