git.gag.com Git - debian/amanda/blob - ndmp-src/ndmp2_translate.c

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