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