1 /*
2 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
3 * Copyright 2014 Nexenta Systems, Inc. All rights reserved.
4 */
5
6 /*
7 * BSD 3 Clause License
8 *
9 * Copyright (c) 2007, The Storage Networking Industry Association.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * - Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 *
17 * - Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in
19 * the documentation and/or other materials provided with the
20 * distribution.
21 *
22 * - Neither the name of The Storage Networking Industry Association (SNIA)
23 * nor the names of its contributors may be used to endorse or promote
24 * products derived from this software without specific prior written
25 * permission.
26 *
27 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
28 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
31 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37 * POSSIBILITY OF SUCH DAMAGE.
38 */
39 /* Copyright (c) 2007, The Storage Networking Industry Association. */
40 /* Copyright (c) 1996, 1997 PDC, Network Appliance. All Rights Reserved */
41 #include <sys/types.h>
42 #include <sys/param.h>
43 #include <sys/socket.h>
44 #include <netinet/in.h>
45 #include <errno.h>
46 #include <arpa/inet.h>
47 #include <stdlib.h>
48 #include <string.h>
49 #include "ndmpd_common.h"
50 #include "ndmpd.h"
51
52 static int ndmpd_data_error_send_v4(ndmpd_session_t *session,
53 ndmp_data_halt_reason reason);
54 static int ndmpd_data_error_send(ndmpd_session_t *session,
55 ndmp_data_halt_reason reason);
56 static void data_accept_connection_v3(void *cookie, int fd, ulong_t mode);
57 static int create_listen_socket_v3(ndmpd_session_t *session, ulong_t *addr,
58 ushort_t *port);
59 static ndmp_error data_connect_sock_v3(ndmpd_session_t *session, ulong_t addr,
60 ushort_t port);
61 static int discard_data_v3(ndmpd_session_t *session, ulong_t length);
62 static void nlp_release_job_stat(ndmpd_session_t *session);
63 static u_longlong_t ndmpd_data_get_info(ndmpd_session_t *session);
64
65 static ndmp_error ndmpd_tar_start_backup_v2(ndmpd_session_t *, char *,
66 ndmp_pval *, ulong_t);
67 static ndmp_error ndmpd_tar_start_recover_v2(ndmpd_session_t *, char *,
68 ndmp_pval *, ulong_t, ndmp_name *, ulong_t);
69 static ndmp_error ndmpd_tar_start_backup_v3(ndmpd_session_t *, char *,
70 ndmp_pval *, ulong_t);
71 static ndmp_error ndmpd_tar_start_recover_v3(ndmpd_session_t *,
72 ndmp_pval *, ulong_t, ndmp_name_v3 *, ulong_t);
73
74 static ndmp_error ndmpd_zfs_start_op(ndmpd_session_t *,
75 ndmp_pval *, ulong_t, ndmp_name_v3 *, ulong_t, enum ndmp_data_operation);
76
77
78 /*
79 * ************************************************************************
80 * NDMP V2 HANDLERS
81 * ************************************************************************
82 */
83
84 /*
85 * ndmpd_data_get_state_v2
86 *
87 * Request handler. Returns current data state.
88 *
89 * Parameters:
90 * connection (input) - connection handle.
91 * body (input) - request message body.
92 *
93 * Returns:
94 * void
95 */
96 /*ARGSUSED*/
97 void
98 ndmpd_data_get_state_v2(ndmp_connection_t *connection, void *body)
99 {
100 ndmp_data_get_state_reply_v2 reply;
101 ndmpd_session_t *session = ndmp_get_client_data(connection);
102
103 reply.error = NDMP_NO_ERR;
104 reply.operation = session->ns_data.dd_operation;
105 reply.state = session->ns_data.dd_state;
106 reply.halt_reason = session->ns_data.dd_halt_reason;
107
108 reply.est_time_remain =
109 session->ns_data.dd_module.dm_stats.ms_est_time_remaining;
110 reply.est_bytes_remain =
111 long_long_to_quad(
112 session->ns_data.dd_module.dm_stats.ms_est_bytes_remaining);
113
114 reply.bytes_processed =
115 long_long_to_quad(ndmpd_data_get_info(session));
116
117 reply.mover = session->ns_data.dd_mover;
118 reply.read_offset = long_long_to_quad(session->ns_data.dd_read_offset);
119 reply.read_length = long_long_to_quad(session->ns_data.dd_read_length);
120
121 ndmp_send_reply(connection, &reply,
122 "sending data_get_state reply");
123 }
124
125
126 /*
127 * ndmpd_data_start_backup_v2
128 *
129 * Request handler. Starts a backup.
130 *
131 * Parameters:
132 * connection (input) - connection handle.
133 * body (input) - request message body.
134 *
135 * Returns:
136 * void
137 */
138 void
139 ndmpd_data_start_backup_v2(ndmp_connection_t *connection, void *body)
140 {
141 ndmp_data_start_backup_request_v2 *request;
142 ndmp_data_start_backup_reply_v2 reply;
143 ndmpd_session_t *session = ndmp_get_client_data(connection);
144 ndmp_error err;
145
146 request = (ndmp_data_start_backup_request_v2 *)body;
147
148 reply.error = NDMP_NO_ERR;
149 session->ns_data.dd_mover = request->mover;
150
151 err = ndmpd_tar_start_backup_v2(session, request->bu_type,
152 request->env.env_val, request->env.env_len);
153
154 /*
155 * start_backup sends the reply if the backup is successfully started.
156 * Otherwise, send the reply containing the error here.
157 */
158 if (err != NDMP_NO_ERR) {
159 NDMP_LOG(LOG_DEBUG, "err: %d", err);
160 reply.error = err;
161 ndmp_send_reply(connection, &reply,
162 "sending data_start_backup reply");
163 ndmpd_data_cleanup(session);
164 }
165 }
166
167 /*
168 * ndmpd_data_start_recover_v2
169 *
170 * Request handler. Starts a restore.
171 *
172 * Parameters:
173 * connection (input) - connection handle.
174 * body (input) - request message body.
175 *
176 * Returns:
177 * void
178 */
179 void
180 ndmpd_data_start_recover_v2(ndmp_connection_t *connection, void *body)
181 {
182 ndmp_data_start_recover_request_v2 *request;
183 ndmp_data_start_recover_reply_v2 reply;
184 ndmpd_session_t *session = ndmp_get_client_data(connection);
185 ndmp_error err;
186
187 request = (ndmp_data_start_recover_request_v2 *) body;
188 session->ns_data.dd_mover = request->mover;
189
190 err = ndmpd_tar_start_recover_v2(session, request->bu_type,
191 request->env.env_val, request->env.env_len,
192 request->nlist.nlist_val, request->nlist.nlist_len);
193
194 /*
195 * start_recover sends the reply if the recover is successfully started.
196 * Otherwise, send the reply containing the error here.
197 */
198 if (err != NDMP_NO_ERR) {
199 reply.error = err;
200 ndmp_send_reply(connection, &reply,
201 "sending ndmp_data_start_recover_request_v2 reply");
202 ndmpd_data_cleanup(session);
203 }
204 }
205
206 /*
207 * ndmpd_data_get_env_v2
208 *
209 * Request handler. Returns the environment variable array sent
210 * with the backup request. This request may only be sent with
211 * a backup operation is in progress.
212 *
213 * Parameters:
214 * connection (input) - connection handle.
215 * body (input) - request message body.
216 *
217 * Returns:
218 * void
219 */
220 /*ARGSUSED*/
221 void
222 ndmpd_data_get_env_v2(ndmp_connection_t *connection, void *body)
223 {
224 ndmp_data_get_env_reply reply;
225 ndmpd_session_t *session = ndmp_get_client_data(connection);
226
227 (void) memset((void*)&reply, 0, sizeof (reply));
228 if (session->ns_data.dd_operation != NDMP_DATA_OP_BACKUP) {
229 NDMP_LOG(LOG_ERR, "Backup operation not active.");
230 reply.error = NDMP_ILLEGAL_STATE_ERR;
231 reply.env.env_len = 0;
232 } else {
233 reply.error = NDMP_NO_ERR;
234 reply.env.env_len = session->ns_data.dd_env_len;
235 reply.env.env_val = session->ns_data.dd_env;
236 }
237
238 ndmp_send_reply(connection, &reply, "sending data_get_env reply");
239 }
240
241
242 /*
243 * ndmpd_data_stop_v2
244 *
245 * Request handler. Stops the current data operation.
246 *
247 * Parameters:
248 * connection (input) - connection handle.
249 * body (input) - request message body.
250 *
251 * Returns:
252 * void
253 */
254 /*ARGSUSED*/
255 void
256 ndmpd_data_stop_v2(ndmp_connection_t *connection, void *body)
257 {
258 ndmp_data_stop_reply reply;
259 ndmpd_session_t *session = ndmp_get_client_data(connection);
260
261 if (session->ns_data.dd_state != NDMP_DATA_STATE_HALTED) {
262 NDMP_LOG(LOG_ERR, "Invalid state to process stop request.");
263 reply.error = NDMP_ILLEGAL_STATE_ERR;
264 ndmp_send_reply(connection, &reply,
265 "sending data_stop reply");
266 return;
267 }
268 ndmp_waitfor_op(session);
269 ndmpd_data_cleanup(session);
270 ndmpd_file_history_cleanup(session, FALSE);
271
272 nlp_release_job_stat(session);
273
274 /* prepare for another data operation */
275 (void) ndmpd_data_init(session);
276 ndmpd_file_history_init(session);
277
278 reply.error = NDMP_NO_ERR;
279 ndmp_send_reply(connection, &reply, "sending data_stop reply");
280 }
281
282
283 /*
284 * ndmpd_data_abort_v2
285 *
286 * Request handler. Aborts the current backup/restore. The operation
287 * state is not changed to the halted state until after the operation
288 * has actually been aborted and the notify_halt request has been sent.
289 *
290 * Parameters:
291 * connection (input) - connection handle.
292 * body (input) - request message body.
293 *
294 * Returns:
295 * void
296 */
297 /*ARGSUSED*/
298 void
299 ndmpd_data_abort_v2(ndmp_connection_t *connection, void *body)
300 {
301 ndmp_data_abort_reply reply;
302 ndmpd_session_t *session = ndmp_get_client_data(connection);
303
304 if (session->ns_data.dd_state == NDMP_DATA_STATE_IDLE ||
305 session->ns_data.dd_state == NDMP_DATA_STATE_HALTED) {
306 NDMP_LOG(LOG_ERR, "Invalid state to process abort request.");
307 reply.error = NDMP_ILLEGAL_STATE_ERR;
308 ndmp_send_reply(connection, &reply,
309 "sending data_abort reply");
310 return;
311 }
312 /*
313 * Don't go to HALTED state yet. Need to wait for data operation to
314 * abort. When this happens, ndmpd_done will get called and will
315 * perform the halt processing.
316 */
317 session->ns_data.dd_abort = TRUE;
318 (*session->ns_data.dd_module.dm_abort_func)(
319 session->ns_data.dd_module.dm_module_cookie);
320
321 reply.error = NDMP_NO_ERR;
322 ndmp_send_reply(connection, &reply, "sending data_abort reply");
323 }
324
325 /*
326 * ************************************************************************
327 * NDMP V3 HANDLERS
328 * ************************************************************************
329 */
330
331 /*
332 * ndmpd_data_get_state_v3
333 *
334 * Request handler. Returns current data state.
335 *
336 * Parameters:
337 * connection (input) - connection handle.
338 * body (input) - request message body.
339 *
340 * Returns:
341 * void
342 */
343 /*ARGSUSED*/
344 void
345 ndmpd_data_get_state_v3(ndmp_connection_t *connection, void *body)
346 {
347 ndmp_data_get_state_reply_v3 reply;
348 ndmpd_session_t *session = ndmp_get_client_data(connection);
349
350 (void) memset((void*)&reply, 0, sizeof (reply));
351
352 reply.error = NDMP_NO_ERR;
353 reply.invalid = NDMP_DATA_STATE_EST_BYTES_REMAIN_INVALID
354 | NDMP_DATA_STATE_EST_TIME_REMAIN_INVALID;
355 reply.operation = session->ns_data.dd_operation;
356 reply.state = session->ns_data.dd_state;
357 reply.halt_reason = session->ns_data.dd_halt_reason;
358
359 if (reply.operation == NDMP_DATA_OP_BACKUP)
360 reply.bytes_processed =
361 long_long_to_quad(
362 session->ns_data.dd_module.dm_stats.ms_bytes_processed);
363 else
364 reply.bytes_processed =
365 long_long_to_quad(ndmpd_data_get_info(session));
366
367 reply.est_bytes_remain = long_long_to_quad(0LL);
368 reply.est_time_remain = 0;
369 if (session->ns_data.dd_state != NDMP_DATA_STATE_IDLE)
370 ndmp_copy_addr_v3(&reply.data_connection_addr,
371 &session->ns_data.dd_data_addr);
372 reply.read_offset = long_long_to_quad(session->ns_data.dd_read_offset);
373 reply.read_length = long_long_to_quad(session->ns_data.dd_read_length);
374
375 ndmp_send_reply(connection, &reply,
376 "sending ndmp_data_get_state_v3 reply");
377 }
378
379
380 /*
381 * ndmpd_data_start_backup_v3
382 *
383 * Request handler. Starts a backup.
384 *
385 * Parameters:
386 * connection (input) - connection handle.
387 * body (input) - request message body.
388 *
389 * Returns:
390 * void
391 */
392 void
393 ndmpd_data_start_backup_v3(ndmp_connection_t *connection, void *body)
394 {
395 ndmp_data_start_backup_request_v3 *request;
396 ndmp_data_start_backup_reply_v3 reply;
397 ndmpd_session_t *session = ndmp_get_client_data(connection);
398
399 request = (ndmp_data_start_backup_request_v3 *)body;
400
401 (void) memset((void*)&reply, 0, sizeof (reply));
402
403 if (session->ns_data.dd_state != NDMP_DATA_STATE_CONNECTED) {
404 NDMP_LOG(LOG_ERR,
405 "Can't start new backup in current state.");
406 NDMP_LOG(LOG_ERR,
407 "Connection to the mover is not established.");
408 reply.error = NDMP_ILLEGAL_STATE_ERR;
409 goto _error;
410 }
411
412 if (session->ns_data.dd_data_addr.addr_type == NDMP_ADDR_LOCAL) {
413 if (session->ns_tape.td_mode == NDMP_TAPE_READ_MODE) {
414 NDMP_LOG(LOG_ERR, "Write protected device.");
415 reply.error = NDMP_WRITE_PROTECT_ERR;
416 goto _error;
417 }
418 }
419
420 if (strcasecmp(request->bu_type, NDMP_TAR_TYPE) == 0) {
421 session->ns_butype = NDMP_BUTYPE_TAR;
422 } else if (strcasecmp(request->bu_type, NDMP_DUMP_TYPE) == 0) {
423 session->ns_butype = NDMP_BUTYPE_DUMP;
424 } else if (strcasecmp(request->bu_type, NDMP_ZFS_TYPE) == 0) {
425 session->ns_butype = NDMP_BUTYPE_ZFS;
426 } else {
427 char msg_invalid[32];
428 char msg_types[32];
429
430 (void) snprintf(msg_invalid, 32, "Invalid backup type: %s.",
431 request->bu_type);
432 (void) snprintf(msg_types, 32,
433 "Supported backup types are tar, dump, and zfs.");
434
435 NDMP_APILOG((void *) session, NDMP_LOG_ERROR, ++ndmp_log_msg_id,
436 msg_invalid);
437 NDMP_APILOG((void *) session, NDMP_LOG_ERROR, ++ndmp_log_msg_id,
438 msg_types);
439 NDMP_LOG(LOG_ERR, msg_invalid);
440 NDMP_LOG(LOG_ERR, msg_types);
441
442 reply.error = NDMP_ILLEGAL_ARGS_ERR;
443 goto _error;
444 }
445
446 if (session->ns_butype == NDMP_BUTYPE_ZFS) {
447 reply.error = ndmpd_zfs_start_op(session, request->env.env_val,
448 request->env.env_len, NULL, 0, NDMP_DATA_OP_BACKUP);
449 } else {
450 reply.error = ndmpd_tar_start_backup_v3(session,
451 request->bu_type, request->env.env_val,
452 request->env.env_len);
453 }
454
455 /*
456 * *_start_backup* sends the reply if the backup is
457 * successfully started. Otherwise, send the reply
458 * containing the error here.
459 */
460
461 _error:
462
463 if (reply.error != NDMP_NO_ERR) {
464 ndmp_send_reply(connection, &reply,
465 "sending data_start_backup_v3 reply");
466 ndmpd_data_cleanup(session);
467 }
468 }
469
470 /*
471 * ndmpd_data_start_recover_v3
472 *
473 * Request handler. Starts a restore.
474 *
475 * Parameters:
476 * connection (input) - connection handle.
477 * body (input) - request message body.
478 *
479 * Returns:
480 * void
481 */
482 void
483 ndmpd_data_start_recover_v3(ndmp_connection_t *connection, void *body)
484 {
485 ndmp_data_start_recover_request_v3 *request;
486 ndmp_data_start_recover_reply_v3 reply;
487 ndmpd_session_t *session = ndmp_get_client_data(connection);
488
489 request = (ndmp_data_start_recover_request_v3 *)body;
490
491 (void) memset((void*)&reply, 0, sizeof (reply));
492
493 if (session->ns_data.dd_state != NDMP_DATA_STATE_CONNECTED) {
494 NDMP_LOG(LOG_ERR, "Can't start new recover in current state.");
495 reply.error = NDMP_ILLEGAL_STATE_ERR;
496 goto _error;
497 }
498
499 if (strcasecmp(request->bu_type, NDMP_TAR_TYPE) == 0) {
500 session->ns_butype = NDMP_BUTYPE_TAR;
501 } else if (strcasecmp(request->bu_type, NDMP_DUMP_TYPE) == 0) {
502 session->ns_butype = NDMP_BUTYPE_DUMP;
503 } else if (strcasecmp(request->bu_type, NDMP_ZFS_TYPE) == 0) {
504 session->ns_butype = NDMP_BUTYPE_ZFS;
505 } else {
506 char msg_invalid[32];
507 char msg_types[32];
508
509 (void) snprintf(msg_invalid, 32, "Invalid backup type: %s.",
510 request->bu_type);
511 (void) snprintf(msg_types, 32,
512 "Supported backup types are tar, dump, and zfs.");
513
514 NDMP_APILOG((void *) session, NDMP_LOG_ERROR, ++ndmp_log_msg_id,
515 msg_invalid);
516 NDMP_APILOG((void *) session, NDMP_LOG_ERROR, ++ndmp_log_msg_id,
517 msg_types);
518 NDMP_LOG(LOG_ERR, msg_invalid);
519 NDMP_LOG(LOG_ERR, msg_types);
520
521 reply.error = NDMP_ILLEGAL_ARGS_ERR;
522 goto _error;
523 }
524
525 if (session->ns_butype == NDMP_BUTYPE_ZFS) {
526 reply.error = ndmpd_zfs_start_op(session, request->env.env_val,
527 request->env.env_len, request->nlist.nlist_val,
528 request->nlist.nlist_len, NDMP_DATA_OP_RECOVER);
529 } else {
530 reply.error = ndmpd_tar_start_recover_v3(session,
531 request->env.env_val, request->env.env_len,
532 request->nlist.nlist_val, request->nlist.nlist_len);
533 }
534
535 /*
536 * *_start_recover* sends the reply if the recover is
537 * successfully started. Otherwise, send the reply
538 * containing the error here.
539 */
540
541 _error:
542
543 if (reply.error != NDMP_NO_ERR) {
544 ndmp_send_reply(connection, &reply,
545 "sending data_start_recover_v3 reply");
546 ndmpd_data_error(session, NDMP_DATA_HALT_INTERNAL_ERROR);
547 ndmpd_data_cleanup(session);
548 }
549 }
550
551 /*
552 * ndmpd_data_abort_v3
553 *
554 * Request handler. Aborts the current backup/restore. The operation
555 * state is not changed to the halted state until after the operation
556 * has actually been aborted and the notify_halt request has been sent.
557 *
558 * Parameters:
559 * connection (input) - connection handle.
560 * body (input) - request message body.
561 *
562 * Returns:
563 * void
564 */
565 /*ARGSUSED*/
566 void
567 ndmpd_data_abort_v3(ndmp_connection_t *connection, void *body)
568 {
569 ndmp_data_abort_reply reply;
570 ndmpd_session_t *session = ndmp_get_client_data(connection);
571
572 switch (session->ns_data.dd_state) {
573 case NDMP_DATA_STATE_IDLE:
574 reply.error = NDMP_ILLEGAL_STATE_ERR;
575 NDMP_LOG(LOG_ERR, "Invalid state to process abort request.");
576 break;
577
578 case NDMP_DATA_STATE_ACTIVE:
579 /*
580 * Don't go to HALTED state yet. Need to wait for data
581 * operation to abort. When this happens, ndmpd_done_v3
582 * will get called and will perform the halt processing.
583 */
584 reply.error = NDMP_NO_ERR;
585 session->ns_data.dd_abort = TRUE;
586 if (session->ns_data.dd_module.dm_abort_func)
587 (*session->ns_data.dd_module.dm_abort_func)(
588 session->ns_data.dd_module.dm_module_cookie);
589 break;
590
591 case NDMP_DATA_STATE_HALTED:
592 case NDMP_DATA_STATE_LISTEN:
593 case NDMP_DATA_STATE_CONNECTED:
594 reply.error = NDMP_NO_ERR;
595 session->ns_data.dd_abort = TRUE;
596 ndmpd_data_error(session, NDMP_DATA_HALT_ABORTED);
597 break;
598 default:
599 reply.error = NDMP_ILLEGAL_STATE_ERR;
600 NDMP_LOG(LOG_DEBUG, "Unknown data V3 state %d",
601 session->ns_data.dd_state);
602 }
603
604 ndmp_send_reply(connection, &reply,
605 "sending data_abort_v3 reply");
606 }
607
608
609 /*
610 * ndmpd_data_stop_v3
611 *
612 * Request handler. Stops the current data operation.
613 *
614 * Parameters:
615 * connection (input) - connection handle.
616 * body (input) - request message body.
617 *
618 * Returns:
619 * void
620 */
621 /*ARGSUSED*/
622 void
623 ndmpd_data_stop_v3(ndmp_connection_t *connection, void *body)
624 {
625 ndmp_data_stop_reply reply;
626 ndmpd_session_t *session = ndmp_get_client_data(connection);
627
628 if (session->ns_data.dd_state != NDMP_DATA_STATE_HALTED) {
629 NDMP_LOG(LOG_ERR, "Invalid state to process stop request.");
630 reply.error = NDMP_ILLEGAL_STATE_ERR;
631 ndmp_send_reply(connection, &reply,
632 "sending data_stop_v3 reply");
633 return;
634 }
635 ndmp_waitfor_op(session);
636 ndmpd_data_cleanup(session);
637 ndmpd_file_history_cleanup(session, FALSE);
638
639 /* prepare for another data operation */
640 (void) ndmpd_data_init(session);
641 ndmpd_file_history_init(session);
642
643 reply.error = NDMP_NO_ERR;
644 ndmp_send_reply(connection, &reply,
645 "sending data_stop_v3 reply");
646 }
647
648
649 /*
650 * ndmpd_data_listen_v3
651 *
652 * Request handler. Configures the server to listen for a connection
653 * from a remote mover.
654 *
655 * Parameters:
656 * connection (input) - connection handle.
657 * body (input) - request message body.
658 *
659 * Returns:
660 * void
661 */
662 void
663 ndmpd_data_listen_v3(ndmp_connection_t *connection, void *body)
664 {
665 ndmp_data_listen_request_v3 *request;
666 ndmp_data_listen_reply_v3 reply;
667 ndmpd_session_t *session = ndmp_get_client_data(connection);
668 ulong_t addr;
669 ushort_t port;
670
671 request = (ndmp_data_listen_request_v3 *)body;
672
673 (void) memset((void*)&reply, 0, sizeof (reply));
674
675 if (session->ns_data.dd_state != NDMP_DATA_STATE_IDLE) {
676 reply.error = NDMP_ILLEGAL_STATE_ERR;
677 NDMP_LOG(LOG_ERR,
678 "Invalid internal data state to process listen request.");
679 } else if (session->ns_mover.md_state != NDMP_MOVER_STATE_IDLE) {
680 reply.error = NDMP_ILLEGAL_STATE_ERR;
681 NDMP_LOG(LOG_ERR,
682 "Invalid mover state to process listen request.");
683 } else {
684 reply.error = NDMP_NO_ERR;
685 }
686
687 if (reply.error != NDMP_NO_ERR) {
688 ndmp_send_reply(connection, &reply,
689 "ndmp_data_listen_request_v3 reply");
690 return;
691 }
692
693 switch (request->addr_type) {
694 case NDMP_ADDR_LOCAL:
695 reply.data_connection_addr.addr_type = request->addr_type;
696 session->ns_data.dd_data_addr.addr_type = NDMP_ADDR_LOCAL;
697 break;
698 case NDMP_ADDR_TCP:
699 if (create_listen_socket_v3(session, &addr, &port) < 0) {
700 reply.error = NDMP_IO_ERR;
701 break;
702 }
703
704 reply.error = NDMP_NO_ERR;
705 reply.data_connection_addr.addr_type = request->addr_type;
706 reply.data_connection_addr.tcp_ip_v3 = htonl(addr);
707 reply.data_connection_addr.tcp_port_v3 = htons(port);
708 session->ns_data.dd_data_addr.addr_type = NDMP_ADDR_TCP;
709 session->ns_data.dd_data_addr.tcp_ip_v3 = addr;
710 session->ns_data.dd_data_addr.tcp_port_v3 = ntohs(port);
711 NDMP_LOG(LOG_DEBUG, "listen_socket: %d",
712 session->ns_data.dd_listen_sock);
713 break;
714
715 default:
716 NDMP_LOG(LOG_DEBUG, "Invalid address type: %d",
717 request->addr_type);
718 reply.error = NDMP_ILLEGAL_ARGS_ERR;
719 break;
720 }
721
722 if (reply.error == NDMP_NO_ERR)
723 session->ns_data.dd_state = NDMP_DATA_STATE_LISTEN;
724
725 ndmp_send_reply(connection, &reply,
726 "ndmp_data_listen_request_v3 reply");
727 }
728
729
730 /*
731 * ndmpd_data_connect_v3
732 *
733 * Request handler. Connects the data server to either a local
734 * or remote mover.
735 *
736 * Parameters:
737 * connection (input) - connection handle.
738 * body (input) - request message body.
739 *
740 * Returns:
741 * void
742 */
743 void
744 ndmpd_data_connect_v3(ndmp_connection_t *connection, void *body)
745 {
746 ndmp_data_connect_request_v3 *request;
747 ndmp_data_connect_reply_v3 reply;
748 ndmpd_session_t *session = ndmp_get_client_data(connection);
749
750 request = (ndmp_data_connect_request_v3 *)body;
751
752 (void) memset((void*)&reply, 0, sizeof (reply));
753
754 if (!ndmp_valid_v3addr_type(request->addr.addr_type)) {
755 reply.error = NDMP_ILLEGAL_ARGS_ERR;
756 NDMP_LOG(LOG_DEBUG, "Invalid address type %d",
757 request->addr.addr_type);
758 } else if (session->ns_data.dd_state != NDMP_DATA_STATE_IDLE) {
759 reply.error = NDMP_ILLEGAL_STATE_ERR;
760 NDMP_LOG(LOG_ERR, "Invalid state to process connect request.");
761 } else {
762 reply.error = NDMP_NO_ERR;
763 }
764
765 if (reply.error != NDMP_NO_ERR) {
766 ndmp_send_reply(connection, &reply,
767 "sending ndmp_data_connect_v3 reply");
768 return;
769 }
770
771 switch (request->addr.addr_type) {
772 case NDMP_ADDR_LOCAL:
773 /*
774 * Verify that the mover is listening for a
775 * local connection
776 */
777 if (session->ns_mover.md_state != NDMP_MOVER_STATE_LISTEN ||
778 session->ns_mover.md_listen_sock != -1) {
779 reply.error = NDMP_ILLEGAL_STATE_ERR;
780 NDMP_LOG(LOG_ERR,
781 "Mover is not in local listen state.");
782 } else {
783 session->ns_mover.md_state = NDMP_MOVER_STATE_ACTIVE;
784 }
785 break;
786
787 case NDMP_ADDR_TCP:
788 reply.error = data_connect_sock_v3(session,
789 request->addr.tcp_ip_v3, request->addr.tcp_port_v3);
790 break;
791
792 default:
793 reply.error = NDMP_ILLEGAL_ARGS_ERR;
794 NDMP_LOG(LOG_DEBUG, "Invalid address type %d",
795 request->addr.addr_type);
796 }
797
798 if (reply.error == NDMP_NO_ERR)
799 session->ns_data.dd_state = NDMP_DATA_STATE_CONNECTED;
800
801 ndmp_send_reply(connection, &reply,
802 "sending ndmp_data_connect_v3 reply");
803 }
804
805
806 /*
807 * ************************************************************************
808 * NDMP V4 HANDLERS
809 * ************************************************************************
810 */
811
812 /*
813 * ndmpd_data_get_env_v4
814 *
815 * Request handler. Returns the environment variable array sent
816 * with the backup request. This request may only be sent with
817 * a backup operation is in progress.
818 *
819 * Parameters:
820 * connection (input) - connection handle.
821 * body (input) - request message body.
822 *
823 * Returns:
824 * void
825 */
826 /*ARGSUSED*/
827 void
828 ndmpd_data_get_env_v4(ndmp_connection_t *connection, void *body)
829 {
830 ndmp_data_get_env_reply reply;
831 ndmpd_session_t *session = ndmp_get_client_data(connection);
832
833 (void) memset((void*)&reply, 0, sizeof (reply));
834
835 if (session->ns_data.dd_state != NDMP_DATA_STATE_ACTIVE &&
836 session->ns_data.dd_state != NDMP_DATA_STATE_HALTED) {
837 NDMP_LOG(LOG_ERR, "Invalid state for the data server.");
838 reply.error = NDMP_ILLEGAL_STATE_ERR;
839 reply.env.env_len = 0;
840 } else if (session->ns_data.dd_operation != NDMP_DATA_OP_BACKUP) {
841 NDMP_LOG(LOG_ERR, "Backup operation not active.");
842 reply.error = NDMP_ILLEGAL_STATE_ERR;
843 reply.env.env_len = 0;
844 } else {
845 reply.error = NDMP_NO_ERR;
846 reply.env.env_len = session->ns_data.dd_env_len;
847 reply.env.env_val = session->ns_data.dd_env;
848 }
849
850 ndmp_send_reply(connection, &reply, "sending data_get_env reply");
851 }
852
853 /*
854 * ndmpd_data_get_state_v4
855 *
856 * Request handler. Returns current data state.
857 *
858 * Parameters:
859 * connection (input) - connection handle.
860 * body (input) - request message body.
861 *
862 * Returns:
863 * void
864 */
865 /*ARGSUSED*/
866 void
867 ndmpd_data_get_state_v4(ndmp_connection_t *connection, void *body)
868 {
869 ndmp_data_get_state_reply_v4 reply;
870 ndmpd_session_t *session = ndmp_get_client_data(connection);
871
872 (void) memset((void*)&reply, 0, sizeof (reply));
873
874 reply.error = NDMP_NO_ERR;
875 reply.unsupported = NDMP_DATA_STATE_EST_BYTES_REMAIN_INVALID
876 | NDMP_DATA_STATE_EST_TIME_REMAIN_INVALID;
877 reply.operation = session->ns_data.dd_operation;
878 reply.state = session->ns_data.dd_state;
879 reply.halt_reason = session->ns_data.dd_halt_reason;
880
881 if (reply.operation == NDMP_DATA_OP_BACKUP)
882 reply.bytes_processed = long_long_to_quad(
883 session->ns_data.dd_module.dm_stats.ms_bytes_processed);
884 else
885 reply.bytes_processed =
886 long_long_to_quad(ndmpd_data_get_info(session));
887
888 reply.est_bytes_remain = long_long_to_quad(0LL);
889 reply.est_time_remain = 0;
890 if (session->ns_data.dd_state != NDMP_DATA_STATE_IDLE)
891 ndmp_copy_addr_v4(&reply.data_connection_addr,
892 &session->ns_data.dd_data_addr_v4);
893
894 reply.read_offset = long_long_to_quad(session->ns_data.dd_read_offset);
895 reply.read_length = long_long_to_quad(session->ns_data.dd_read_length);
896
897 ndmp_send_reply(connection, &reply,
898 "sending ndmp_data_get_state_v4 reply");
899 free(reply.data_connection_addr.tcp_addr_v4);
900 }
901
902
903 /*
904 * ndmpd_data_connect_v4
905 *
906 * Request handler. Connects the data server to either a local
907 * or remote mover.
908 *
909 * Parameters:
910 * connection (input) - connection handle.
911 * body (input) - request message body.
912 *
913 * Returns:
914 * void
915 */
916 void
917 ndmpd_data_connect_v4(ndmp_connection_t *connection, void *body)
918 {
919 ndmp_data_connect_request_v4 *request;
920 ndmp_data_connect_reply_v4 reply;
921 ndmpd_session_t *session = ndmp_get_client_data(connection);
922
923 request = (ndmp_data_connect_request_v4 *)body;
924
925 (void) memset((void*)&reply, 0, sizeof (reply));
926
927 if (!ndmp_valid_v3addr_type(request->addr.addr_type)) {
928 reply.error = NDMP_ILLEGAL_ARGS_ERR;
929 NDMP_LOG(LOG_DEBUG, "Invalid address type %d",
930 request->addr.addr_type);
931 } else if (session->ns_data.dd_state != NDMP_DATA_STATE_IDLE) {
932 reply.error = NDMP_ILLEGAL_STATE_ERR;
933 NDMP_LOG(LOG_ERR, "Invalid state to process connect request.");
934 } else {
935 reply.error = NDMP_NO_ERR;
936 }
937
938 if (reply.error != NDMP_NO_ERR) {
939 ndmp_send_reply(connection, &reply,
940 "sending ndmp_data_connect_v4 reply");
941 return;
942 }
943
944 switch (request->addr.addr_type) {
945 case NDMP_ADDR_LOCAL:
946 /*
947 * Verify that the mover is listening for a
948 * local connection
949 */
950 if (session->ns_mover.md_state != NDMP_MOVER_STATE_LISTEN ||
951 session->ns_mover.md_listen_sock != -1) {
952 reply.error = NDMP_ILLEGAL_STATE_ERR;
953 NDMP_LOG(LOG_ERR,
954 "Mover is not in local listen state.");
955 } else {
956 session->ns_mover.md_state = NDMP_MOVER_STATE_ACTIVE;
957 }
958 break;
959
960 case NDMP_ADDR_TCP:
961 reply.error = data_connect_sock_v3(session,
962 request->addr.tcp_ip_v4(0), request->addr.tcp_port_v4(0));
963 break;
964
965 default:
966 reply.error = NDMP_ILLEGAL_ARGS_ERR;
967 NDMP_LOG(LOG_DEBUG, "Invalid address type %d",
968 request->addr.addr_type);
969 }
970
971 if (reply.error == NDMP_NO_ERR)
972 session->ns_data.dd_state = NDMP_DATA_STATE_CONNECTED;
973
974 ndmp_send_reply(connection, &reply,
975 "sending ndmp_data_connect_v4 reply");
976 }
977
978 /*
979 * ndmpd_data_listen_v4
980 *
981 * Request handler. Configures the server to listen for a connection
982 * from a remote mover.
983 *
984 * Parameters:
985 * connection (input) - connection handle.
986 * body (input) - request message body.
987 *
988 * Returns:
989 * void
990 */
991 void
992 ndmpd_data_listen_v4(ndmp_connection_t *connection, void *body)
993 {
994 ndmp_data_listen_request_v4 *request;
995 ndmp_data_listen_reply_v4 reply;
996 ndmpd_session_t *session = ndmp_get_client_data(connection);
997 ulong_t addr;
998 ushort_t port;
999
1000 request = (ndmp_data_listen_request_v4 *)body;
1001
1002 (void) memset((void*)&reply, 0, sizeof (reply));
1003
1004 if (session->ns_data.dd_state != NDMP_DATA_STATE_IDLE) {
1005 reply.error = NDMP_ILLEGAL_STATE_ERR;
1006 NDMP_LOG(LOG_ERR,
1007 "Invalid internal data state to process listen request.");
1008 } else if (session->ns_mover.md_state != NDMP_MOVER_STATE_IDLE) {
1009 reply.error = NDMP_ILLEGAL_STATE_ERR;
1010 NDMP_LOG(LOG_ERR,
1011 "Invalid mover state to process listen request.");
1012 } else {
1013 reply.error = NDMP_NO_ERR;
1014 }
1015
1016 if (reply.error != NDMP_NO_ERR) {
1017 ndmp_send_reply(connection, &reply,
1018 "ndmp_data_listen_request_v4 reply");
1019 return;
1020 }
1021
1022 switch (request->addr_type) {
1023 case NDMP_ADDR_LOCAL:
1024 reply.connect_addr.addr_type = request->addr_type;
1025 session->ns_data.dd_data_addr.addr_type = NDMP_ADDR_LOCAL;
1026 break;
1027 case NDMP_ADDR_TCP:
1028 if (create_listen_socket_v3(session, &addr, &port) < 0) {
1029 reply.error = NDMP_IO_ERR;
1030 break;
1031 }
1032
1033 reply.error = NDMP_NO_ERR;
1034 reply.connect_addr.addr_type = request->addr_type;
1035 reply.connect_addr.tcp_addr_v4 =
1036 ndmp_malloc(sizeof (ndmp_tcp_addr_v4));
1037
1038 reply.connect_addr.tcp_ip_v4(0) = htonl(addr);
1039 reply.connect_addr.tcp_port_v4(0) = htons(port);
1040 reply.connect_addr.tcp_len_v4 = 1;
1041
1042 session->ns_data.dd_data_addr_v4.addr_type = NDMP_ADDR_TCP;
1043 session->ns_data.dd_data_addr_v4.tcp_addr_v4 =
1044 ndmp_malloc(sizeof (ndmp_tcp_addr_v4));
1045
1046 session->ns_data.dd_data_addr_v4.tcp_ip_v4(0) = addr;
1047 session->ns_data.dd_data_addr_v4.tcp_port_v4(0) = ntohs(port);
1048 session->ns_data.dd_data_addr_v4.tcp_len_v4 = 1;
1049
1050 /* Copy that to data_addr for compatibility */
1051 session->ns_data.dd_data_addr.addr_type = NDMP_ADDR_TCP;
1052 session->ns_data.dd_data_addr.tcp_ip_v3 = addr;
1053 session->ns_data.dd_data_addr.tcp_port_v3 = ntohs(port);
1054 NDMP_LOG(LOG_DEBUG, "listen_socket: %d",
1055 session->ns_data.dd_listen_sock);
1056 break;
1057
1058 default:
1059 NDMP_LOG(LOG_DEBUG, "Invalid address type: %d",
1060 request->addr_type);
1061 reply.error = NDMP_ILLEGAL_ARGS_ERR;
1062 break;
1063 }
1064
1065 if (reply.error == NDMP_NO_ERR)
1066 session->ns_data.dd_state = NDMP_DATA_STATE_LISTEN;
1067
1068 ndmp_send_reply(connection, &reply,
1069 "ndmp_data_listen_request_v4 reply");
1070 }
1071
1072
1073 /*
1074 * ndmpd_data_start_recover_filehist_v4
1075 *
1076 * Request handler. Recovers the file history (not supported yet)
1077 * This command has an optional support in V4.
1078 *
1079 * Parameters:
1080 * connection (input) - connection handle.
1081 * body (input) - request message body.
1082 *
1083 * Returns:
1084 * void
1085 */
1086 /*ARGSUSED*/
1087 void
1088 ndmpd_data_start_recover_filehist_v4(ndmp_connection_t *connection, void *body)
1089 {
1090 ndmp_data_start_recover_filehist_reply_v4 reply;
1091
1092 NDMP_LOG(LOG_DEBUG, "Request not supported");
1093 reply.error = NDMP_NOT_SUPPORTED_ERR;
1094
1095 ndmp_send_reply(connection, &reply,
1096 "sending ndmp_data_start_recover_filehist_reply_v4 reply");
1097 }
1098
1099 /*
1100 * ************************************************************************
1101 * LOCALS
1102 * ************************************************************************
1103 */
1104
1105 /*
1106 * ndmpd_data_error_send
1107 *
1108 * This function sends the notify message to the client.
1109 *
1110 * Parameters:
1111 * session (input) - session pointer.
1112 * reason (input) - halt reason.
1113 *
1114 * Returns:
1115 * Error code
1116 */
1117 /*ARGSUSED*/
1118 static int
1119 ndmpd_data_error_send(ndmpd_session_t *session, ndmp_data_halt_reason reason)
1120 {
1121 ndmp_notify_data_halted_request req;
1122
1123 req.reason = session->ns_data.dd_halt_reason;
1124 req.text_reason = "";
1125
1126 return (ndmp_send_request(session->ns_connection,
1127 NDMP_NOTIFY_DATA_HALTED, NDMP_NO_ERR, &req, 0));
1128 }
1129
1130
1131 /*
1132 * ndmpd_data_error_send_v4
1133 *
1134 * This function sends the notify message to the client.
1135 *
1136 * Parameters:
1137 * session (input) - session pointer.
1138 * reason (input) - halt reason.
1139 *
1140 * Returns:
1141 * Error code
1142 */
1143 /*ARGSUSED*/
1144 static int
1145 ndmpd_data_error_send_v4(ndmpd_session_t *session, ndmp_data_halt_reason reason)
1146 {
1147 ndmp_notify_data_halted_request_v4 req;
1148
1149 req.reason = session->ns_data.dd_halt_reason;
1150
1151 return ndmp_send_request(session->ns_connection,
1152 NDMP_NOTIFY_DATA_HALTED, NDMP_NO_ERR, &req, 0);
1153 }
1154
1155
1156 /*
1157 * ndmpd_data_error
1158 *
1159 * This function is called when a data error has been detected.
1160 * A notify message is sent to the client and the data server is
1161 * placed into the halted state.
1162 *
1163 * Parameters:
1164 * session (input) - session pointer.
1165 * reason (input) - halt reason.
1166 *
1167 * Returns:
1168 * void
1169 */
1170 void
1171 ndmpd_data_error(ndmpd_session_t *session, ndmp_data_halt_reason reason)
1172 {
1173 if (session->ns_data.dd_state == NDMP_DATA_STATE_IDLE ||
1174 session->ns_data.dd_state == NDMP_DATA_STATE_HALTED)
1175 return;
1176
1177 if (session->ns_data.dd_operation == NDMP_DATA_OP_BACKUP) {
1178 /*
1179 * Send/discard any buffered file history data.
1180 */
1181 ndmpd_file_history_cleanup(session,
1182 (reason == NDMP_DATA_HALT_SUCCESSFUL ? TRUE : FALSE));
1183
1184 /*
1185 * If mover local and successful backup, write any
1186 * remaining buffered data to tape.
1187 */
1188 if (session->ns_data.dd_data_addr.addr_type
1189 == NDMP_ADDR_LOCAL && reason == NDMP_DATA_HALT_SUCCESSFUL)
1190 (void) ndmpd_local_write_v3(session, 0, 0);
1191 }
1192
1193 session->ns_data.dd_state = NDMP_DATA_STATE_HALTED;
1194 session->ns_data.dd_halt_reason = reason;
1195
1196 if (session->ns_protocol_version == NDMPV4) {
1197 if (ndmpd_data_error_send_v4(session, reason) < 0)
1198 NDMP_LOG(LOG_DEBUG,
1199 "Error sending notify_data_halted request");
1200 } else {
1201 if (ndmpd_data_error_send(session, reason) < 0)
1202 NDMP_LOG(LOG_DEBUG,
1203 "Error sending notify_data_halted request");
1204 }
1205
1206 if (session->ns_data.dd_data_addr.addr_type == NDMP_ADDR_TCP) {
1207 if (session->ns_data.dd_sock != -1) {
1208 (void) ndmpd_remove_file_handler(session,
1209 session->ns_data.dd_sock);
1210 /*
1211 * ndmpcopy: we use the same socket for the mover,
1212 * so expect to close when mover is done!
1213 */
1214 if (session->ns_data.dd_sock !=
1215 session->ns_mover.md_sock)
1216 (void) close(session->ns_data.dd_sock);
1217
1218 session->ns_data.dd_sock = -1;
1219 }
1220 if (session->ns_data.dd_listen_sock != -1) {
1221 (void) ndmpd_remove_file_handler(session,
1222 session->ns_data.dd_listen_sock);
1223
1224 (void) close(session->ns_data.dd_listen_sock);
1225 session->ns_data.dd_listen_sock = -1;
1226 }
1227 } else {
1228 ndmpd_mover_error(session, NDMP_MOVER_HALT_CONNECT_CLOSED);
1229 }
1230 }
1231
1232
1233 /*
1234 * data_accept_connection_v3
1235 *
1236 * Accept a data connection from a remote mover.
1237 * Called by ndmpd_select when a connection is pending on
1238 * the data listen socket.
1239 *
1240 * Parameters:
1241 * cookie (input) - session pointer.
1242 * fd (input) - file descriptor.
1243 * mode (input) - select mode.
1244 *
1245 * Returns:
1246 * void
1247 */
1248 /*ARGSUSED*/
1249 static void
1250 data_accept_connection_v3(void *cookie, int fd, ulong_t mode)
1251 {
1252 ndmpd_session_t *session = (ndmpd_session_t *)cookie;
1253 int from_len;
1254 struct sockaddr_in from;
1255
1256 from_len = sizeof (from);
1257 session->ns_data.dd_sock = accept(fd, (struct sockaddr *)&from,
1258 &from_len);
1259
1260 NDMP_LOG(LOG_DEBUG, "sock fd: %d",
1261 session->ns_data.dd_sock);
1262 NDMP_LOG(LOG_DEBUG, "sin: port %d addr %s",
1263 ntohs(from.sin_port),
1264 inet_ntoa(IN_ADDR(from.sin_addr.s_addr)));
1265
1266 (void) ndmpd_remove_file_handler(session, fd);
1267 (void) close(session->ns_data.dd_listen_sock);
1268 session->ns_data.dd_listen_sock = -1;
1269
1270 if (session->ns_data.dd_sock < 0) {
1271 NDMP_LOG(LOG_DEBUG, "Accept error: %m");
1272 ndmpd_data_error(session, NDMP_DATA_HALT_CONNECT_ERROR);
1273 return;
1274 }
1275
1276 /*
1277 * Save the peer address.
1278 */
1279 session->ns_data.dd_data_addr.tcp_ip_v3 = from.sin_addr.s_addr;
1280 session->ns_data.dd_data_addr.tcp_port_v3 = ntohs(from.sin_port);
1281
1282 /* Set the parameter of the new socket */
1283 set_socket_options(session->ns_data.dd_sock);
1284
1285 session->ns_data.dd_state = NDMP_DATA_STATE_CONNECTED;
1286 }
1287
1288
1289 /*
1290 * create_listen_socket_v3
1291 *
1292 * Creates the data sockets for listening for a remote mover/data
1293 * incoming connections.
1294 */
1295 static int
1296 create_listen_socket_v3(ndmpd_session_t *session, ulong_t *addr, ushort_t *port)
1297 {
1298 session->ns_data.dd_listen_sock = ndmp_create_socket(addr, port);
1299 if (session->ns_data.dd_listen_sock < 0)
1300 return (-1);
1301
1302 /*
1303 * Add a file handler for the listen socket.
1304 * ndmpd_select will call data_accept_connection when a
1305 * connection is ready to be accepted.
1306 */
1307 if (ndmpd_add_file_handler(session, (void*)session,
1308 session->ns_data.dd_listen_sock, NDMPD_SELECT_MODE_READ, HC_MOVER,
1309 data_accept_connection_v3) < 0) {
1310 (void) close(session->ns_data.dd_listen_sock);
1311 session->ns_data.dd_listen_sock = -1;
1312 return (-1);
1313 }
1314 NDMP_LOG(LOG_DEBUG, "addr: %s:%d",
1315 inet_ntoa(IN_ADDR(*addr)), ntohs(*port));
1316
1317 return (0);
1318 }
1319
1320
1321 /*
1322 * data_connect_sock_v3
1323 *
1324 * Connect the data interface socket to the specified ip/port
1325 *
1326 * Parameters:
1327 * session (input) - session pointer.
1328 * addr (input) - IP address
1329 * port (input) - port number
1330 *
1331 * Returns:
1332 * NDMP_NO_ERR - backup successfully started.
1333 * otherwise - error code of backup start error.
1334 */
1335 static ndmp_error
1336 data_connect_sock_v3(ndmpd_session_t *session, ulong_t addr, ushort_t port)
1337 {
1338 int sock;
1339
1340 sock = ndmp_connect_sock_v3(addr, port);
1341 if (sock < 0)
1342 return (NDMP_CONNECT_ERR);
1343
1344 session->ns_data.dd_sock = sock;
1345 session->ns_data.dd_data_addr.addr_type = NDMP_ADDR_TCP;
1346 session->ns_data.dd_data_addr.tcp_ip_v3 = ntohl(addr);
1347 session->ns_data.dd_data_addr.tcp_port_v3 = port;
1348
1349 return (NDMP_NO_ERR);
1350 }
1351
1352
1353 /*
1354 * ndmpd_tar_start_backup_v3
1355 *
1356 * Start the backup work
1357 *
1358 * Parameters:
1359 * session (input) - session pointer.
1360 * bu_type (input) - backup type.
1361 * env_val (input) - environment variable array.
1362 * env_len (input) - length of env_val.
1363 *
1364 * Returns:
1365 * NDMP_NO_ERR - backup successfully started.
1366 * otherwise - error code of backup start error.
1367 */
1368 static ndmp_error
1369 ndmpd_tar_start_backup_v3(ndmpd_session_t *session, char *bu_type,
1370 ndmp_pval *env_val, ulong_t env_len)
1371 {
1372 int err;
1373 ndmp_lbr_params_t *nlp;
1374 ndmpd_module_params_t *params;
1375 ndmp_data_start_backup_reply_v3 reply;
1376
1377 (void) memset((void*)&reply, 0, sizeof (reply));
1378
1379 err = ndmpd_save_env(session, env_val, env_len);
1380 if (err != NDMP_NO_ERR)
1381 return (err);
1382
1383 nlp = ndmp_get_nlp(session);
1384 NDMP_FREE(nlp->nlp_params);
1385 params = nlp->nlp_params = ndmp_malloc(sizeof (ndmpd_module_params_t));
1386 if (!params)
1387 return (NDMP_NO_MEM_ERR);
1388
1389 params->mp_daemon_cookie = (void *)session;
1390 params->mp_module_cookie = &session->ns_data.dd_module.dm_module_cookie;
1391 params->mp_protocol_version = session->ns_protocol_version;
1392 params->mp_operation = NDMP_DATA_OP_BACKUP;
1393 params->mp_get_env_func = ndmpd_api_get_env;
1394 params->mp_add_env_func = ndmpd_api_add_env;
1395 params->mp_set_env_func = ndmpd_api_set_env;
1396 params->mp_get_name_func = 0;
1397 params->mp_dispatch_func = ndmpd_api_dispatch;
1398 params->mp_done_func = ndmpd_api_done_v3;
1399 if (session->ns_protocol_version == NDMPV4)
1400 params->mp_log_func_v3 = ndmpd_api_log_v4;
1401 else
1402 params->mp_log_func_v3 = ndmpd_api_log_v3;
1403
1404 params->mp_add_file_handler_func = ndmpd_api_add_file_handler;
1405 params->mp_remove_file_handler_func = ndmpd_api_remove_file_handler;
1406 params->mp_write_func = ndmpd_api_write_v3;
1407 params->mp_read_func = 0;
1408 params->mp_file_recovered_func = 0;
1409 params->mp_stats = &session->ns_data.dd_module.dm_stats;
1410 session->ns_data.dd_module.dm_module_cookie = 0;
1411
1412 if (strcmp(bu_type, NDMP_DUMP_TYPE) == 0) {
1413 NLP_SET(nlp, NLPF_DUMP);
1414 params->mp_file_history_path_func = 0;
1415 params->mp_file_history_dir_func =
1416 ndmpd_api_file_history_dir_v3;
1417 params->mp_file_history_node_func =
1418 ndmpd_api_file_history_node_v3;
1419 } else if (strcmp(bu_type, NDMP_TAR_TYPE) == 0) {
1420 NLP_SET(nlp, NLPF_TAR);
1421 params->mp_file_history_path_func =
1422 ndmpd_api_file_history_file_v3;
1423 params->mp_file_history_dir_func = 0;
1424 params->mp_file_history_node_func = 0;
1425 } else {
1426 NLP_UNSET(nlp, NLPF_DUMP);
1427 NLP_UNSET(nlp, NLPF_TAR);
1428 }
1429
1430 session->ns_data.dd_module.dm_start_func = ndmpd_tar_backup_starter_v3;
1431 session->ns_data.dd_module.dm_abort_func = ndmpd_tar_backup_abort_v3;
1432
1433 session->ns_data.dd_module.dm_stats.ms_est_bytes_remaining = 0;
1434 session->ns_data.dd_module.dm_stats.ms_est_time_remaining = 0;
1435 session->ns_data.dd_nlist_v3 = 0;
1436 session->ns_data.dd_nlist_len = 0;
1437 session->ns_data.dd_bytes_left_to_read = 0;
1438 session->ns_data.dd_position = 0;
1439 session->ns_data.dd_discard_length = 0;
1440 session->ns_data.dd_read_offset = 0;
1441 session->ns_data.dd_read_length = 0;
1442
1443 reply.error = ndmp_backup_get_params_v3(session, params);
1444 if (reply.error != NDMP_NO_ERR) {
1445 NDMP_LOG(LOG_DEBUG, "err: %d", err);
1446 NDMP_FREE(nlp->nlp_params);
1447 return (reply.error);
1448 }
1449
1450 reply.error = NDMP_NO_ERR;
1451 if (ndmp_send_response(session->ns_connection, NDMP_NO_ERR,
1452 &reply) < 0) {
1453 NDMP_LOG(LOG_DEBUG, "Sending data_start_backup_v3 reply");
1454 return (NDMP_NO_ERR);
1455 }
1456
1457 NS_INC(nbk);
1458 session->ns_data.dd_state = NDMP_DATA_STATE_ACTIVE;
1459 session->ns_data.dd_operation = NDMP_DATA_OP_BACKUP;
1460 session->ns_data.dd_abort = FALSE;
1461
1462 /*
1463 * perform the backup
1464 *
1465 * Cannot wait for the thread to exit as we are replying to the
1466 * client request here.
1467 */
1468 err = pthread_create(NULL, NULL,
1469 (funct_t)session->ns_data.dd_module.dm_start_func,
1470 params);
1471 if (err != 0) {
1472 NDMP_LOG(LOG_ERR, "Can't start backup session.");
1473 return (NDMP_ILLEGAL_ARGS_ERR);
1474 }
1475
1476 return (NDMP_NO_ERR);
1477 }
1478
1479 /*
1480 * ndmpd_tar_start_recover_v3
1481 *
1482 * Start the restore work
1483 *
1484 * Parameters:
1485 * session (input) - session pointer.
1486 * bu_type (input) - backup type.
1487 * env_val (input) - environment variable array.
1488 * env_len (input) - length of env_val.
1489 * nlist_val (input) - list of files.
1490 * nlist_len (input) - length of nlist_val.
1491 *
1492 * Returns:
1493 * NDMP_NO_ERR - recover successfully started.
1494 * otherwise - error code of recover start error.
1495 */
1496 static ndmp_error
1497 ndmpd_tar_start_recover_v3(ndmpd_session_t *session,
1498 ndmp_pval *env_val, ulong_t env_len, ndmp_name_v3 *nlist_val,
1499 ulong_t nlist_len)
1500 {
1501 ndmp_data_start_recover_reply_v3 reply;
1502 ndmpd_module_params_t *params;
1503 ndmp_lbr_params_t *nlp;
1504 int err;
1505
1506 (void) memset((void*)&reply, 0, sizeof (reply));
1507
1508 nlp = ndmp_get_nlp(session);
1509 NDMP_FREE(nlp->nlp_params);
1510 params = nlp->nlp_params = ndmp_malloc(sizeof (ndmpd_module_params_t));
1511 if (!params) {
1512 return (NDMP_NO_MEM_ERR);
1513 }
1514
1515 reply.error = ndmpd_save_env(session, env_val, env_len);
1516 if (reply.error != NDMP_NO_ERR) {
1517 NDMP_FREE(nlp->nlp_params);
1518 return (NDMP_NO_MEM_ERR);
1519 }
1520
1521 reply.error = ndmpd_save_nlist_v3(session, nlist_val, nlist_len);
1522 if (reply.error != NDMP_NO_ERR) {
1523 NDMP_FREE(nlp->nlp_params);
1524 return (NDMP_NO_MEM_ERR);
1525 }
1526
1527 /*
1528 * Setup restore parameters.
1529 */
1530 params->mp_daemon_cookie = (void *)session;
1531 params->mp_module_cookie = &session->ns_data.dd_module.dm_module_cookie;
1532 params->mp_protocol_version = session->ns_protocol_version;
1533 params->mp_operation = NDMP_DATA_OP_RECOVER;
1534 params->mp_get_env_func = ndmpd_api_get_env;
1535 params->mp_add_env_func = ndmpd_api_add_env;
1536 params->mp_set_env_func = ndmpd_api_set_env;
1537 params->mp_get_name_func = ndmpd_api_get_name_v3;
1538 params->mp_dispatch_func = ndmpd_api_dispatch;
1539 params->mp_done_func = ndmpd_api_done_v3;
1540 if (session->ns_protocol_version == NDMPV4) {
1541 params->mp_log_func_v3 = ndmpd_api_log_v4;
1542 params->mp_file_recovered_func = ndmpd_api_file_recovered_v4;
1543 } else {
1544 params->mp_log_func_v3 = ndmpd_api_log_v3;
1545 params->mp_file_recovered_func = ndmpd_api_file_recovered_v3;
1546 }
1547
1548 params->mp_add_file_handler_func = ndmpd_api_add_file_handler;
1549 params->mp_remove_file_handler_func = ndmpd_api_remove_file_handler;
1550 params->mp_write_func = 0;
1551 params->mp_file_history_path_func = 0;
1552 params->mp_file_history_dir_func = 0;
1553 params->mp_file_history_node_func = 0;
1554 params->mp_read_func = ndmpd_api_read_v3;
1555 params->mp_seek_func = ndmpd_api_seek_v3;
1556 params->mp_stats = &session->ns_data.dd_module.dm_stats;
1557
1558 session->ns_data.dd_module.dm_module_cookie = 0;
1559 session->ns_data.dd_module.dm_start_func = ndmpd_tar_restore_starter_v3;
1560 session->ns_data.dd_module.dm_abort_func = ndmpd_tar_restore_abort_v3;
1561 session->ns_data.dd_module.dm_stats.ms_est_bytes_remaining = 0;
1562 session->ns_data.dd_module.dm_stats.ms_est_time_remaining = 0;
1563 session->ns_data.dd_bytes_left_to_read = 0;
1564 session->ns_data.dd_position = 0;
1565 session->ns_data.dd_discard_length = 0;
1566 session->ns_data.dd_read_offset = 0;
1567 session->ns_data.dd_read_length = 0;
1568
1569 err = ndmp_restore_get_params_v3(session, params);
1570 if (err != NDMP_NO_ERR) {
1571 NDMP_FREE(nlp->nlp_params);
1572 return (err);
1573 }
1574
1575 reply.error = NDMP_NO_ERR;
1576 if (ndmp_send_response(session->ns_connection, NDMP_NO_ERR,
1577 &reply) < 0) {
1578 NDMP_FREE(nlp->nlp_params);
1579 ndmpd_free_nlist_v3(session);
1580 NDMP_LOG(LOG_DEBUG,
1581 "Error sending ndmp_data_start_recover_reply");
1582 ndmpd_data_error(session, NDMP_DATA_HALT_CONNECT_ERROR);
1583 return (NDMP_NO_ERR);
1584 }
1585
1586 NS_INC(nrs);
1587 session->ns_data.dd_state = NDMP_DATA_STATE_ACTIVE;
1588 session->ns_data.dd_operation = NDMP_DATA_OP_RECOVER;
1589 session->ns_data.dd_abort = FALSE;
1590
1591 /*
1592 * perform the restore
1593 *
1594 * Cannot wait for the thread to exit as we are replying to the
1595 * client request here.
1596 */
1597 err = pthread_create(NULL, NULL,
1598 (funct_t)session->ns_data.dd_module.dm_start_func,
1599 params);
1600
1601 if (err != 0) {
1602 NDMP_LOG(LOG_ERR, "Can't start recover session.");
1603 return (NDMP_ILLEGAL_ARGS_ERR);
1604 }
1605 return (NDMP_NO_ERR);
1606 }
1607
1608 static ndmp_error
1609 ndmpd_zfs_start_op(ndmpd_session_t *session, ndmp_pval *env_val,
1610 ulong_t env_len, ndmp_name_v3 *nlist_val, ulong_t nlist_len,
1611 enum ndmp_data_operation op)
1612 {
1613 ndmpd_zfs_args_t *ndmpd_zfs_args = &session->ns_ndmpd_zfs_args;
1614 ndmp_data_start_backup_reply_v3 backup_reply;
1615 ndmp_data_start_recover_reply_v3 recover_reply;
1616 pthread_t tid;
1617 void *reply;
1618 char str[8];
1619 int err;
1620
1621 if (ndmpd_zfs_init(session) != 0)
1622 return (NDMP_UNDEFINED_ERR);
1623
1624 err = ndmpd_save_env(session, env_val, env_len);
1625 if (err != NDMP_NO_ERR) {
1626 ndmpd_zfs_fini(ndmpd_zfs_args);
1627 return (err);
1628 }
1629
1630 switch (op) {
1631 case NDMP_DATA_OP_BACKUP:
1632 if (!ndmpd_zfs_backup_parms_valid(ndmpd_zfs_args)) {
1633 ndmpd_zfs_fini(ndmpd_zfs_args);
1634 return (NDMP_ILLEGAL_ARGS_ERR);
1635 }
1636
1637 if (ndmpd_zfs_pre_backup(ndmpd_zfs_args)) {
1638 NDMP_LOG(LOG_ERR, "pre_backup error");
1639 return (NDMP_ILLEGAL_ARGS_ERR);
1640 }
1641
1642 session->ns_data.dd_module.dm_start_func =
1643 ndmpd_zfs_backup_starter;
1644 (void) strlcpy(str, "backup", 8);
1645 break;
1646 case NDMP_DATA_OP_RECOVER:
1647 err = ndmpd_save_nlist_v3(session, nlist_val, nlist_len);
1648 if (err != NDMP_NO_ERR) {
1649 ndmpd_zfs_fini(ndmpd_zfs_args);
1650 return (NDMP_NO_MEM_ERR);
1651 }
1652
1653 if (!ndmpd_zfs_restore_parms_valid(ndmpd_zfs_args)) {
1654 ndmpd_zfs_fini(ndmpd_zfs_args);
1655 return (NDMP_ILLEGAL_ARGS_ERR);
1656 }
1657
1658 if (ndmpd_zfs_pre_restore(ndmpd_zfs_args)) {
1659 NDMP_LOG(LOG_ERR, "pre_restore error");
1660 (void) ndmpd_zfs_post_restore(ndmpd_zfs_args);
1661 return (NDMP_ILLEGAL_ARGS_ERR);
1662 }
1663 session->ns_data.dd_module.dm_start_func =
1664 ndmpd_zfs_restore_starter;
1665 (void) strlcpy(str, "recover", 8);
1666 break;
1667 }
1668
1669 ndmpd_zfs_params->mp_operation = op;
1670 session->ns_data.dd_operation = op;
1671 session->ns_data.dd_module.dm_abort_func = ndmpd_zfs_abort;
1672 session->ns_data.dd_state = NDMP_DATA_STATE_ACTIVE;
1673 session->ns_data.dd_abort = FALSE;
1674
1675 if (op == NDMP_DATA_OP_BACKUP) {
1676 (void) memset((void*)&backup_reply, 0, sizeof (backup_reply));
1677 backup_reply.error = NDMP_NO_ERR;
1678 reply = &backup_reply;
1679 } else {
1680 (void) memset((void*)&recover_reply, 0, sizeof (recover_reply));
1681 recover_reply.error = NDMP_NO_ERR;
1682 reply = &recover_reply;
1683 }
1684
1685 if (ndmp_send_response(session->ns_connection, NDMP_NO_ERR,
1686 reply) < 0) {
1687 NDMP_LOG(LOG_DEBUG, "Sending data_start_%s_v3 reply", str);
1688 if (op == NDMP_DATA_OP_RECOVER)
1689 ndmpd_data_error(session, NDMP_DATA_HALT_CONNECT_ERROR);
1690 ndmpd_zfs_fini(ndmpd_zfs_args);
1691 return (NDMP_NO_ERR);
1692 }
1693
1694 err = pthread_create(&tid, NULL,
1695 (funct_t)session->ns_data.dd_module.dm_start_func, ndmpd_zfs_args);
1696
1697 if (err) {
1698 NDMP_LOG(LOG_ERR, "Can't start %s session (errno %d)",
1699 str, err);
1700 ndmpd_zfs_fini(ndmpd_zfs_args);
1701 MOD_DONE(ndmpd_zfs_params, -1);
1702 return (NDMP_NO_ERR);
1703 }
1704
1705 (void) pthread_detach(tid);
1706
1707 if (op == NDMP_DATA_OP_BACKUP)
1708 NS_INC(nbk);
1709 else
1710 NS_INC(nrs);
1711
1712 ndmpd_zfs_dma_log(ndmpd_zfs_args, NDMP_LOG_NORMAL,
1713 "'zfs' %s starting\n", str);
1714
1715 return (NDMP_NO_ERR);
1716 }
1717
1718 /*
1719 * discard_data_v3
1720 *
1721 * Read and discard data from the data connection.
1722 * Called when a module has called ndmpd_seek() prior to
1723 * reading all of the data from the previous seek.
1724 *
1725 * Parameters:
1726 * session (input) - session pointer.
1727 *
1728 * Returns:
1729 * number of bytes read and discarded.
1730 * -1 - error.
1731 */
1732 static int
1733 discard_data_v3(ndmpd_session_t *session, ulong_t length)
1734 {
1735 static char buf[MAX_RECORD_SIZE];
1736 int n, toread;
1737
1738 toread = (length < MAX_RECORD_SIZE) ? length :
1739 MAX_RECORD_SIZE;
1740
1741 /* Read and discard the data. */
1742 n = read(session->ns_data.dd_sock, buf, toread);
1743 if (n < 0) {
1744 NDMP_LOG(LOG_ERR, "Socket read error: %m.");
1745 n = -1;
1746 }
1747
1748 return (n);
1749 }
1750
1751
1752 /*
1753 * ndmpd_remote_read_v3
1754 *
1755 * Reads data from the remote mover.
1756 *
1757 * Parameters:
1758 * session (input) - session pointer.
1759 * data (input) - data to be written.
1760 * length (input) - data length.
1761 *
1762 * Returns:
1763 * 0 - data successfully read.
1764 * -1 - error.
1765 */
1766 int
1767 ndmpd_remote_read_v3(ndmpd_session_t *session, char *data, ulong_t length)
1768 {
1769 ulong_t count;
1770 ulong_t len;
1771 ssize_t n;
1772 ndmp_notify_data_read_request request;
1773 tlm_job_stats_t *jstat;
1774 longlong_t fsize;
1775
1776 NDMP_LOG(LOG_DEBUG, "ns_data.dd_xx: [%llu, %llu, %llu, %llu, %llu]",
1777 session->ns_data.dd_bytes_left_to_read,
1778 session->ns_data.dd_read_offset,
1779 session->ns_data.dd_read_length,
1780 session->ns_data.dd_position,
1781 session->ns_data.dd_discard_length);
1782
1783 count = 0;
1784 while (count < length) {
1785 len = length - count;
1786
1787 /*
1788 * If the end of the seek window has been reached then
1789 * send an ndmp_read request to the client.
1790 * The NDMP client will then send a mover_data_read request to
1791 * the remote mover and the mover will send more data.
1792 * This condition can occur if the module attempts to read past
1793 * a seek window set via a prior call to ndmpd_seek() or
1794 * the module has not issued a seek. If no seek was issued then
1795 * pretend that a seek was issued to read the entire tape.
1796 */
1797 if (session->ns_data.dd_bytes_left_to_read == 0) {
1798 /* ndmpd_seek() never called? */
1799 if (session->ns_data.dd_read_length == 0) {
1800 session->ns_data.dd_bytes_left_to_read = ~0LL;
1801 session->ns_data.dd_read_offset = 0LL;
1802 session->ns_data.dd_read_length = ~0LL;
1803 } else {
1804 /*
1805 * While restoring a file, restoreFile()
1806 * records the number of bytes still need to
1807 * be restored. We use this as a guidance
1808 * when asking for data from the tape.
1809 */
1810 jstat = session->ns_ndmp_lbr_params->nlp_jstat;
1811 fsize = jstat->js_bytes_in_file;
1812
1813 NDMP_LOG(LOG_DEBUG, "bytes_left [%llu / %u]",
1814 fsize, len);
1815
1816 /*
1817 * Fall back to the old way if fsize if too
1818 * small.
1819 */
1820 if (fsize < len)
1821 fsize = len;
1822
1823 session->ns_data.dd_bytes_left_to_read = fsize;
1824 session->ns_data.dd_read_offset =
1825 session->ns_data.dd_position;
1826 session->ns_data.dd_read_length = fsize;
1827 }
1828
1829 request.offset =
1830 long_long_to_quad(session->ns_data.dd_read_offset);
1831 request.length =
1832 long_long_to_quad(session->ns_data.dd_read_length);
1833
1834 NDMP_LOG(LOG_DEBUG, "to NOTIFY_DATA_READ [%llu, %llu]",
1835 session->ns_data.dd_read_offset,
1836 session->ns_data.dd_read_length);
1837
1838 if (ndmp_send_request_lock(session->ns_connection,
1839 NDMP_NOTIFY_DATA_READ, NDMP_NO_ERR,
1840 &request, 0) < 0) {
1841 NDMP_LOG(LOG_DEBUG,
1842 "Sending notify_data_read request");
1843 return (-1);
1844 }
1845 }
1846
1847 /*
1848 * If the module called ndmpd_seek() prior to reading all of the
1849 * data that the remote mover was requested to send, then the
1850 * excess data from the seek has to be discarded.
1851 */
1852 if (session->ns_data.dd_discard_length != 0) {
1853 n = discard_data_v3(session,
1854 (ulong_t)session->ns_data.dd_discard_length);
1855 if (n < 0)
1856 return (-1);
1857
1858 session->ns_data.dd_discard_length -= n;
1859 continue;
1860 }
1861
1862 /*
1863 * Don't attempt to read more data than the remote is sending.
1864 */
1865 if (len > session->ns_data.dd_bytes_left_to_read)
1866 len = session->ns_data.dd_bytes_left_to_read;
1867
1868 if ((n = read(session->ns_data.dd_sock, &data[count],
1869 len)) < 0) {
1870 NDMP_LOG(LOG_ERR, "Socket read error: %m.");
1871 return (-1);
1872 }
1873
1874 /* read returns 0 if the connection was closed */
1875 if (n == 0) {
1876 NDMP_LOG(LOG_DEBUG, "n 0 errno %d",
1877 errno);
1878 return (-1);
1879 }
1880
1881 count += n;
1882 session->ns_data.dd_bytes_left_to_read -= n;
1883 session->ns_data.dd_position += n;
1884 }
1885 return (0);
1886 }
1887
1888 /*
1889 * nlp_release_job_stat
1890 *
1891 * Unreference the job statistics
1892 *
1893 * Parameters:
1894 * session (input) - session pointer.
1895 *
1896 * Returns:
1897 * void
1898 */
1899 static void
1900 nlp_release_job_stat(ndmpd_session_t *session)
1901 {
1902 ndmp_lbr_params_t *nlp;
1903
1904 if ((nlp = ndmp_get_nlp(session)) == NULL) {
1905 NDMP_LOG(LOG_DEBUG, "nlp == NULL");
1906 return;
1907 }
1908 if (nlp->nlp_jstat != NULL) {
1909 nlp->nlp_bytes_total =
1910 (u_longlong_t)nlp->nlp_jstat->js_bytes_total;
1911 tlm_un_ref_job_stats(nlp->nlp_jstat->js_job_name);
1912 nlp->nlp_jstat = NULL;
1913 } else
1914 NDMP_LOG(LOG_DEBUG, "JSTAT == NULL");
1915 }
1916
1917
1918 /* *** ndmpd global internal functions *********************************** */
1919
1920 /*
1921 * ndmpd_data_init
1922 *
1923 * Initializes data specific session variables.
1924 *
1925 * Parameters:
1926 * session (input) - session pointer.
1927 *
1928 * Returns:
1929 * void
1930 */
1931 int
1932 ndmpd_data_init(ndmpd_session_t *session)
1933 {
1934 session->ns_data.dd_operation = NDMP_DATA_OP_NOACTION;
1935 session->ns_data.dd_state = NDMP_DATA_STATE_IDLE;
1936 session->ns_data.dd_halt_reason = NDMP_DATA_HALT_NA;
1937 session->ns_data.dd_abort = FALSE;
1938 session->ns_data.dd_env = 0;
1939 session->ns_data.dd_env_len = 0;
1940 session->ns_data.dd_nlist = 0;
1941 session->ns_data.dd_nlist_len = 0;
1942 session->ns_data.dd_mover.addr_type = NDMP_ADDR_LOCAL;
1943 session->ns_data.dd_sock = -1;
1944 session->ns_data.dd_read_offset = 0;
1945 session->ns_data.dd_read_length = 0;
1946 session->ns_data.dd_module.dm_stats.ms_est_bytes_remaining = 0;
1947 session->ns_data.dd_module.dm_stats.ms_est_time_remaining = 0;
1948 /*
1949 * NDMP V3
1950 */
1951 session->ns_data.dd_state = NDMP_DATA_STATE_IDLE;
1952 session->ns_data.dd_nlist_v3 = 0;
1953 session->ns_data.dd_data_addr.addr_type = NDMP_ADDR_LOCAL;
1954 session->ns_data.dd_listen_sock = -1;
1955 session->ns_data.dd_bytes_left_to_read = 0LL;
1956 session->ns_data.dd_position = 0LL;
1957 session->ns_data.dd_discard_length = 0LL;
1958 return (0);
1959 }
1960
1961
1962
1963 /*
1964 * ndmpd_data_cleanup
1965 *
1966 * Releases resources allocated during a data operation.
1967 *
1968 * Parameters:
1969 * session (input) - session pointer.
1970 *
1971 * Returns:
1972 * void
1973 */
1974 void
1975 ndmpd_data_cleanup(ndmpd_session_t *session)
1976 {
1977 if (session->ns_data.dd_listen_sock != -1) {
1978 NDMP_LOG(LOG_DEBUG, "data.listen_sock: %d",
1979 session->ns_data.dd_listen_sock);
1980 (void) ndmpd_remove_file_handler(session,
1981 session->ns_data.dd_listen_sock);
1982 (void) close(session->ns_data.dd_listen_sock);
1983 session->ns_data.dd_listen_sock = -1;
1984 }
1985 if (session->ns_data.dd_sock != -1) {
1986 NDMP_LOG(LOG_DEBUG, "data.sock: %d",
1987 session->ns_data.dd_sock);
1988
1989 /*
1990 * ndmpcopy: we use the same socket for the mover,
1991 * so expect to close when mover is done!
1992 */
1993 if (session->ns_data.dd_sock != session->ns_mover.md_sock)
1994 (void) close(session->ns_data.dd_sock);
1995
1996 session->ns_data.dd_sock = -1;
1997 }
1998
1999 ndmpd_free_env(session);
2000 ndmpd_free_nlist(session);
2001 }
2002
2003
2004 /*
2005 * ndmp_data_get_mover_mode
2006 *
2007 * Return the mover mode
2008 *
2009 * Parameters:
2010 * session (input) - session pointer.
2011 *
2012 * Returns:
2013 * remote - remote backup
2014 * local - local backup
2015 */
2016 char *
2017 ndmp_data_get_mover_mode(ndmpd_session_t *session)
2018 {
2019 char *rv;
2020
2021 switch (session->ns_protocol_version) {
2022 case NDMPV2:
2023 rv = ((session->ns_data.dd_mover.addr_type == NDMP_ADDR_TCP)
2024 ? "remote" : "local");
2025 break;
2026 case NDMPV3:
2027 rv = ((session->ns_data.dd_data_addr.addr_type == NDMP_ADDR_TCP)
2028 ? "remote" : "local");
2029 break;
2030 case NDMPV4:
2031 rv = ((session->ns_data.dd_data_addr.addr_type ==
2032 NDMP_ADDR_TCP ||
2033 (session->ns_data.dd_data_addr_v4.addr_type ==
2034 NDMP_ADDR_TCP)) ? "remote" : "local");
2035 break;
2036 default:
2037 rv = "Unknown";
2038 NDMP_LOG(LOG_ERR, "Invalid protocol version %d.",
2039 session->ns_protocol_version);
2040 }
2041
2042 return (rv);
2043 }
2044
2045 /* *** static functions ******************************************** */
2046
2047 /*
2048 * ndmpd_tar_start_backup_v2
2049 *
2050 * Request handling code common to version 1 and
2051 * version 2 data_start_backup request handlers.
2052 *
2053 * Parameters:
2054 * session (input) - session pointer.
2055 * bu_type (input) - backup type.
2056 * env_val (input) - environment variable array.
2057 * env_len (input) - length of env_val.
2058 *
2059 * Returns:
2060 * NDMP_NO_ERR - backup successfully started.
2061 * otherwise - error code of backup start error.
2062 */
2063 static ndmp_error
2064 ndmpd_tar_start_backup_v2(ndmpd_session_t *session, char *bu_type,
2065 ndmp_pval *env_val, ulong_t env_len)
2066 {
2067 ndmp_data_start_backup_reply reply;
2068 ndmpd_module_params_t *params;
2069 ndmp_lbr_params_t *nlp;
2070 int err;
2071
2072 if (session->ns_data.dd_state != NDMP_DATA_STATE_IDLE) {
2073 NDMP_LOG(LOG_ERR, "Can't start new backup in current state.");
2074 return (NDMP_ILLEGAL_STATE_ERR);
2075 }
2076 if (strcmp(bu_type, NDMP_DUMP_TYPE) != 0 &&
2077 strcmp(bu_type, NDMP_TAR_TYPE) != 0) {
2078 NDMP_LOG(LOG_ERR, "Invalid backup type: %s.", bu_type);
2079 NDMP_LOG(LOG_ERR, "Supported backup types are tar and dump.");
2080 return (NDMP_ILLEGAL_ARGS_ERR);
2081 }
2082 if ((err = ndmpd_save_env(session, env_val, env_len)) != NDMP_NO_ERR)
2083 return (err);
2084
2085 nlp = ndmp_get_nlp(session);
2086 NDMP_FREE(nlp->nlp_params);
2087 params = nlp->nlp_params = ndmp_malloc(sizeof (ndmpd_module_params_t));
2088 if (params == NULL)
2089 return (NDMP_NO_MEM_ERR);
2090
2091 params->mp_daemon_cookie = (void *)session;
2092 params->mp_module_cookie = &session->ns_data.dd_module.dm_module_cookie;
2093 params->mp_protocol_version = session->ns_protocol_version;
2094 params->mp_operation = NDMP_DATA_OP_BACKUP;
2095 params->mp_get_env_func = ndmpd_api_get_env;
2096 params->mp_add_env_func = ndmpd_api_add_env;
2097 params->mp_get_name_func = ndmpd_api_get_name;
2098 params->mp_dispatch_func = ndmpd_api_dispatch;
2099 params->mp_done_func = ndmpd_api_done_v2;
2100 params->mp_log_func = ndmpd_api_log_v2;
2101 params->mp_add_file_handler_func = ndmpd_api_add_file_handler;
2102 params->mp_remove_file_handler_func = ndmpd_api_remove_file_handler;
2103 params->mp_write_func = ndmpd_api_write_v2;
2104 params->mp_read_func = 0;
2105 params->mp_file_recovered_func = 0;
2106 params->mp_stats = &session->ns_data.dd_module.dm_stats;
2107
2108 session->ns_data.dd_module.dm_module_cookie = 0;
2109 if (strcmp(bu_type, NDMP_DUMP_TYPE) == 0) {
2110 NLP_SET(nlp, NLPF_DUMP);
2111 params->mp_file_history_path_func = 0;
2112 params->mp_file_history_dir_func =
2113 ndmpd_api_file_history_dir_v2;
2114 params->mp_file_history_node_func =
2115 ndmpd_api_file_history_node_v2;
2116 } else if (strcmp(bu_type, NDMP_TAR_TYPE) == 0) {
2117 /* backup type == NDMP_TAR_TYPE */
2118 NLP_SET(nlp, NLPF_TAR);
2119 params->mp_file_history_path_func =
2120 ndmpd_api_file_history_path_v2;
2121 params->mp_file_history_dir_func = 0;
2122 params->mp_file_history_node_func = 0;
2123 } else {
2124 NLP_UNSET(nlp, NLPF_DUMP);
2125 NLP_UNSET(nlp, NLPF_TAR);
2126 }
2127
2128 session->ns_data.dd_module.dm_start_func = ndmpd_tar_backup_starter;
2129 session->ns_data.dd_module.dm_abort_func = ndmpd_tar_backup_abort;
2130
2131 session->ns_data.dd_module.dm_stats.ms_est_bytes_remaining = 0;
2132 session->ns_data.dd_module.dm_stats.ms_est_time_remaining = 0;
2133 session->ns_data.dd_nlist = 0;
2134 session->ns_data.dd_nlist_len = 0;
2135 session->ns_data.dd_read_offset = 0;
2136 session->ns_data.dd_read_length = 0;
2137
2138 if ((err = ndmp_backup_extract_params(session,
2139 params)) != NDMP_NO_ERR) {
2140 NDMP_LOG(LOG_DEBUG, "err: %d", err);
2141 NDMP_FREE(nlp->nlp_params);
2142 return (err);
2143 }
2144
2145 err = ndmpd_mover_connect(session, NDMP_MOVER_MODE_READ);
2146 if (err != NDMP_NO_ERR) {
2147 NDMP_LOG(LOG_DEBUG,
2148 "mover connect err: %d", err);
2149 NDMP_FREE(nlp->nlp_params);
2150 return (err);
2151 }
2152
2153 session->ns_data.dd_state = NDMP_DATA_STATE_ACTIVE;
2154
2155 session->ns_data.dd_operation = NDMP_DATA_OP_BACKUP;
2156 session->ns_data.dd_abort = FALSE;
2157
2158 NDMP_LOG(LOG_DEBUG, "starting backup");
2159
2160 reply.error = NDMP_NO_ERR;
2161 if (ndmp_send_response(session->ns_connection, NDMP_NO_ERR,
2162 &reply) < 0) {
2163 NDMP_LOG(LOG_DEBUG, "Sending data_start_backup reply");
2164 NDMP_FREE(nlp->nlp_params);
2165 if (session->ns_data.dd_mover.addr_type == NDMP_ADDR_TCP) {
2166 /*
2167 * ndmpcopy: we use the same socket for the mover,
2168 * so expect to close when mover is done!
2169 */
2170 if (session->ns_data.dd_sock !=
2171 session->ns_mover.md_sock)
2172 (void) close(session->ns_data.dd_sock);
2173
2174 session->ns_data.dd_sock = -1;
2175 } else
2176 ndmpd_mover_error(session,
2177 NDMP_MOVER_HALT_CONNECT_CLOSED);
2178 return (NDMP_NO_ERR);
2179 }
2180
2181 /*
2182 * perform the backup
2183 *
2184 * Cannot wait for the thread to exit as we are replying to the
2185 * client request here.
2186 */
2187 (void) pthread_create(NULL, NULL,
2188 (funct_t)session->ns_data.dd_module.dm_start_func,
2189 params);
2190
2191 return (NDMP_NO_ERR);
2192 }
2193
2194 /*
2195 * ndmpd_tar_start_recover_v2
2196 *
2197 * The main recover/restore function
2198 *
2199 * Parameters:
2200 * session (input) - session pointer.
2201 * bu_type (input) - backup type.
2202 * env_val (input) - environment variable array.
2203 * env_len (input) - length of env_val.
2204 * nlist_val (input) - list of files.
2205 * nlist_len (input) - length of nlist_val.
2206 *
2207 * Returns:
2208 * NDMP_NO_ERR - recover successfully started.
2209 * otherwise - error code of backup start error.
2210 */
2211 static ndmp_error
2212 ndmpd_tar_start_recover_v2(ndmpd_session_t *session, char *bu_type,
2213 ndmp_pval *env_val, ulong_t env_len, ndmp_name *nlist_val,
2214 ulong_t nlist_len)
2215 {
2216 ndmp_data_start_recover_reply_v2 reply;
2217 ndmpd_module_params_t *params;
2218 ndmp_lbr_params_t *nlp;
2219 int err;
2220
2221 if (session->ns_data.dd_state != NDMP_DATA_STATE_IDLE) {
2222 NDMP_LOG(LOG_ERR, "Can't start new recover in current state.");
2223 return (NDMP_ILLEGAL_STATE_ERR);
2224 }
2225
2226 if (strcmp(bu_type, NDMP_DUMP_TYPE) != 0 &&
2227 strcmp(bu_type, NDMP_TAR_TYPE) != 0) {
2228 NDMP_LOG(LOG_ERR, "Invalid backup type: %s.", bu_type);
2229 NDMP_LOG(LOG_ERR, "Supported backup types are tar and dump.");
2230 return (NDMP_ILLEGAL_ARGS_ERR);
2231 }
2232
2233 reply.error = ndmpd_save_env(session, env_val, env_len);
2234 if (reply.error != NDMP_NO_ERR)
2235 return (NDMP_NO_MEM_ERR);
2236
2237 reply.error = ndmpd_save_nlist_v2(session, nlist_val, nlist_len);
2238 if (reply.error != NDMP_NO_ERR)
2239 return (NDMP_NO_MEM_ERR);
2240
2241 nlp = ndmp_get_nlp(session);
2242 NDMP_FREE(nlp->nlp_params);
2243 params = nlp->nlp_params = ndmp_malloc(sizeof (ndmpd_module_params_t));
2244 if (params == NULL)
2245 return (NDMP_NO_MEM_ERR);
2246
2247 /*
2248 * Setup restore parameters.
2249 */
2250 params->mp_daemon_cookie = (void *)session;
2251 params->mp_module_cookie = &session->ns_data.dd_module.dm_module_cookie;
2252 params->mp_protocol_version = session->ns_protocol_version;
2253 params->mp_operation = NDMP_DATA_OP_RECOVER;
2254 params->mp_get_env_func = ndmpd_api_get_env;
2255 params->mp_add_env_func = ndmpd_api_add_env;
2256 params->mp_get_name_func = ndmpd_api_get_name;
2257 params->mp_dispatch_func = ndmpd_api_dispatch;
2258 params->mp_done_func = ndmpd_api_done_v2;
2259 params->mp_log_func = ndmpd_api_log_v2;
2260 params->mp_add_file_handler_func = ndmpd_api_add_file_handler;
2261 params->mp_remove_file_handler_func = ndmpd_api_remove_file_handler;
2262 params->mp_write_func = 0;
2263 params->mp_file_history_path_func = 0;
2264 params->mp_file_history_dir_func = 0;
2265 params->mp_file_history_node_func = 0;
2266 params->mp_read_func = ndmpd_api_read_v2;
2267 params->mp_seek_func = ndmpd_api_seek_v2;
2268 params->mp_file_recovered_func = ndmpd_api_file_recovered_v2;
2269 params->mp_stats = &session->ns_data.dd_module.dm_stats;
2270
2271 session->ns_data.dd_module.dm_module_cookie = 0;
2272 session->ns_data.dd_module.dm_start_func = ndmpd_tar_restore_starter;
2273 session->ns_data.dd_module.dm_abort_func = ndmpd_tar_restore_abort;
2274 session->ns_data.dd_module.dm_stats.ms_est_bytes_remaining = 0;
2275 session->ns_data.dd_module.dm_stats.ms_est_time_remaining = 0;
2276 session->ns_data.dd_read_offset = 0;
2277 session->ns_data.dd_read_length = 0;
2278
2279 if ((err = ndmp_restore_extract_params(session,
2280 params)) != NDMP_NO_ERR) {
2281 NDMP_FREE(nlp->nlp_params);
2282 return (err);
2283 }
2284
2285 err = ndmpd_mover_connect(session, NDMP_MOVER_MODE_WRITE);
2286 if (err != NDMP_NO_ERR) {
2287 NDMP_FREE(nlp->nlp_params);
2288 return (err);
2289 }
2290
2291 session->ns_data.dd_state = NDMP_DATA_STATE_ACTIVE;
2292 session->ns_data.dd_operation = NDMP_DATA_OP_RECOVER;
2293 session->ns_data.dd_abort = FALSE;
2294
2295 reply.error = NDMP_NO_ERR;
2296 if (ndmp_send_response(session->ns_connection, NDMP_NO_ERR,
2297 &reply) < 0) {
2298 NDMP_LOG(LOG_DEBUG, "Sending data_start_recover reply");
2299 NDMP_FREE(nlp->nlp_params);
2300 if (session->ns_data.dd_mover.addr_type == NDMP_ADDR_TCP) {
2301 /*
2302 * ndmpcopy: we use the same socket for the mover,
2303 * so expect to close when mover is done!
2304 */
2305 if (session->ns_data.dd_sock !=
2306 session->ns_mover.md_sock)
2307 (void) close(session->ns_data.dd_sock);
2308
2309 session->ns_data.dd_sock = -1;
2310 } else {
2311 ndmpd_mover_error(session,
2312 NDMP_MOVER_HALT_CONNECT_CLOSED);
2313 }
2314 return (NDMP_NO_ERR);
2315 }
2316
2317
2318 /*
2319 * perform the restore
2320 *
2321 * Cannot wait for the thread to exit as we are replying to the
2322 * client request here.
2323 */
2324 (void) pthread_create(NULL, NULL,
2325 (funct_t)session->ns_data.dd_module.dm_start_func,
2326 params);
2327
2328 return (NDMP_NO_ERR);
2329 }
2330
2331 /*
2332 * ndmpd_data_get_info
2333 *
2334 * Return the total number of bytes processed
2335 *
2336 * Parameters:
2337 * session (input) - session pointer.
2338 *
2339 * Returns:
2340 * the number of bytes processed
2341 */
2342 static u_longlong_t
2343 ndmpd_data_get_info(ndmpd_session_t *session)
2344 {
2345 ndmp_lbr_params_t *nlp;
2346
2347 nlp = ndmp_get_nlp(session);
2348 if (nlp == NULL)
2349 return ((u_longlong_t)0);
2350
2351 if (nlp->nlp_jstat == NULL)
2352 return (nlp->nlp_bytes_total);
2353
2354 return ((u_longlong_t)nlp->nlp_jstat->js_bytes_total);
2355 }