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