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