1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 2017 Peter Tribble.
24 */
25
26 /*
27 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
28 * Use is subject to license terms.
29 */
30
31 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
32 /* All Rights Reserved */
33
34
35
36 #include <stdio.h>
37 #include <string.h>
38 #include <signal.h>
39 #include <stdlib.h>
40 #include <unistd.h>
41 #include <sys/types.h>
42 #include <sys/param.h>
43 #include <sys/sysmacros.h>
44 #include <errno.h>
45 #include <sys/types.h>
46 #include <sys/stat.h>
47 #include <sys/statvfs.h>
48 #include <fcntl.h>
49 #include "pkglib.h"
50 #include "pkglibmsgs.h"
51 #include "pkglocale.h"
52
53 /* libadm.a */
54 extern char *devattr(char *device, char *attribute);
55 extern int pkgnmchk(register char *pkg, register char *spec,
56 int presvr4flg);
57 extern int getvol(char *device, char *label, int options, char *prompt);
58
59 #define CMDSIZ 512
60 #define LSIZE 128
61 #define DDPROC "/usr/bin/dd"
62 #define CPIOPROC "/usr/bin/cpio"
63
64 /* device types */
65
66 #define G_TM_TAPE 1 /* Tapemaster controller */
67 #define G_XY_DISK 3 /* xy disks */
68 #define G_SD_DISK 7 /* scsi sd disk */
69 #define G_XT_TAPE 8 /* xt tapes */
70 #define G_SF_FLOPPY 9 /* sf floppy */
71 #define G_XD_DISK 10 /* xd disks */
72 #define G_ST_TAPE 11 /* scsi tape */
73 #define G_NS 12 /* noswap pseudo-dev */
74 #define G_RAM 13 /* ram pseudo-dev */
75 #define G_FT 14 /* tftp */
76 #define G_HD 15 /* 386 network disk */
77 #define G_FD 16 /* 386 AT disk */
78 #define G_FILE 28 /* file, not a device */
79 #define G_NO_DEV 29 /* device does not require special treatment */
80 #define G_DEV_MAX 30 /* last valid device type */
81
82 struct dstoc {
83 int cnt;
84 char pkg[NON_ABI_NAMELNGTH];
85 int nparts;
86 long maxsiz;
87 char volnos[128];
88 struct dstoc *next;
89 } *ds_head, *ds_toc;
90
91 #define ds_nparts ds_toc->nparts
92 #define ds_maxsiz ds_toc->maxsiz
93
94 int ds_totread; /* total number of parts read */
95 int ds_fd = -1;
96 int ds_curpartcnt = -1;
97
98 int ds_next(char *device, char *instdir);
99 int ds_ginit(char *device);
100 int ds_close(int pkgendflg);
101
102 static FILE *ds_pp;
103 static int ds_realfd = -1; /* file descriptor for real device */
104 static int ds_read; /* number of parts read for current package */
105 static int ds_volno; /* volume number of current volume */
106 static int ds_volcnt; /* total number of volumes */
107 static char ds_volnos[128]; /* parts/volume info */
108 static char *ds_device;
109 static int ds_volpart; /* number of parts read in current volume, */
110 /* including skipped parts */
111 static int ds_bufsize;
112 static int ds_skippart; /* number of parts skipped in current volume */
113
114 static int ds_getnextvol(char *device);
115 static int ds_skip(char *device, int nskip);
116
117 void
ds_order(char * list[])118 ds_order(char *list[])
119 {
120 struct dstoc *toc_pt;
121 register int j, n;
122 char *pt;
123
124 toc_pt = ds_head;
125 n = 0;
126 while (toc_pt) {
127 for (j = n; list[j]; j++) {
128 if (strcmp(list[j], toc_pt->pkg) == 0) {
129 /* just swap places in the array */
130 pt = list[n];
131 list[n++] = list[j];
132 list[j] = pt;
133 }
134 }
135 toc_pt = toc_pt->next;
136 }
137 }
138
139 static char *pds_header;
140 static char *ds_header;
141 static int ds_headsize;
142
143 static char *
ds_gets(char * buf,int size)144 ds_gets(char *buf, int size)
145 {
146 int length;
147 char *nextp;
148
149 nextp = strchr(pds_header, '\n');
150 if (nextp == NULL) {
151 length = strlen(pds_header);
152 if (length > size)
153 return (0);
154 if ((ds_header = (char *)realloc(ds_header,
155 ds_headsize + BLK_SIZE)) == NULL)
156 return (0);
157 if (read(ds_fd, ds_header + ds_headsize, BLK_SIZE) < BLK_SIZE)
158 return (0);
159 ds_headsize += BLK_SIZE;
160 nextp = strchr(pds_header, '\n');
161 if (nextp == NULL)
162 return (0);
163 *nextp = '\0';
164 if (length + (int)strlen(pds_header) > size)
165 return (0);
166 (void) strncpy(buf + length, pds_header, strlen(pds_header));
167 buf[length + strlen(pds_header)] = '\0';
168 pds_header = nextp + 1;
169 return (buf);
170 }
171 *nextp = '\0';
172 if ((int)strlen(pds_header) > size)
173 return (0);
174 (void) strncpy(buf, pds_header, strlen(pds_header));
175 buf[strlen(pds_header)] = '\0';
176 pds_header = nextp + 1;
177 return (buf);
178 }
179
180 /*
181 * function to determine if media is datastream or mounted
182 * floppy
183 */
184 int
ds_readbuf(char * device)185 ds_readbuf(char *device)
186 {
187 char buf[BLK_SIZE];
188
189 if (ds_fd >= 0)
190 (void) close(ds_fd);
191 if ((ds_fd = open(device, O_RDONLY)) >= 0 &&
192 read(ds_fd, buf, BLK_SIZE) == BLK_SIZE &&
193 strncmp(buf, HDR_PREFIX, 20) == 0) {
194 if ((ds_header = (char *)calloc(BLK_SIZE, 1)) == NULL) {
195 progerr(pkg_gt(ERR_UNPACK));
196 logerr(pkg_gt(MSG_MEM));
197 (void) ds_close(0);
198 return (0);
199 }
200 (void) memcpy(ds_header, buf, BLK_SIZE);
201 ds_headsize = BLK_SIZE;
202
203 if (ds_ginit(device) < 0) {
204 progerr(pkg_gt(ERR_UNPACK));
205 logerr(pkg_gt(MSG_OPEN), device, errno);
206 (void) ds_close(0);
207 return (0);
208 }
209 return (1);
210 } else if (ds_fd >= 0) {
211 (void) close(ds_fd);
212 ds_fd = -1;
213 }
214 return (0);
215 }
216
217 /*
218 * Determine how many additional volumes are needed for current package.
219 * Note: a 0 will occur as first volume number when the package begins
220 * on the next volume.
221 */
222 static int
ds_volsum(struct dstoc * toc)223 ds_volsum(struct dstoc *toc)
224 {
225 int curpartcnt, volcnt;
226 char volnos[128], tmpvol[128];
227 if (toc->volnos[0]) {
228 int index, sum;
229 (void) sscanf(toc->volnos, "%d %[ 0-9]", &curpartcnt, volnos);
230 volcnt = 0;
231 sum = curpartcnt;
232 while (sum < toc->nparts && sscanf(volnos, "%d %[ 0-9]",
233 &index, tmpvol) >= 1) {
234 (void) strcpy(volnos, tmpvol);
235 volcnt++;
236 sum += index;
237 }
238 /* side effect - set number of parts read on current volume */
239 ds_volpart = index;
240 return (volcnt);
241 }
242 ds_volpart += toc->nparts;
243 return (0);
244 }
245
246 /* initialize ds_curpartcnt and ds_volnos */
247 static void
ds_pkginit(void)248 ds_pkginit(void)
249 {
250 if (ds_toc->volnos[0])
251 (void) sscanf(ds_toc->volnos, "%d %[ 0-9]", &ds_curpartcnt,
252 ds_volnos);
253 else
254 ds_curpartcnt = -1;
255 }
256
257 /*
258 * functions to pass current package info to exec'ed program
259 */
260 void
ds_putinfo(char * buf,size_t sz)261 ds_putinfo(char *buf, size_t sz)
262 {
263 (void) snprintf(buf, sz, "%d %d %d %d %d %d %d %d %d %d %s",
264 ds_fd, ds_realfd, ds_volcnt, ds_volno, ds_totread, ds_volpart,
265 ds_skippart, ds_bufsize, ds_toc->nparts, ds_toc->maxsiz,
266 ds_toc->volnos);
267 }
268
269 int
ds_getinfo(char * string)270 ds_getinfo(char *string)
271 {
272 ds_toc = (struct dstoc *)calloc(1, sizeof (struct dstoc));
273 (void) sscanf(string, "%d %d %d %d %d %d %d %d %d %d %[ 0-9]",
274 &ds_fd, &ds_realfd, &ds_volcnt, &ds_volno, &ds_totread,
275 &ds_volpart, &ds_skippart, &ds_bufsize, &ds_toc->nparts,
276 &ds_toc->maxsiz, ds_toc->volnos);
277 ds_pkginit();
278 return (ds_toc->nparts);
279 }
280
281 /*
282 * Return true if the file descriptor (ds_fd) is open on the package stream.
283 */
284 boolean_t
ds_fd_open(void)285 ds_fd_open(void)
286 {
287 return (ds_fd >= 0 ? B_TRUE : B_FALSE);
288 }
289
290 /*
291 * Read the source device. Acquire the header data and check it for validity.
292 */
293 int
ds_init(char * device,char ** pkg,char * norewind)294 ds_init(char *device, char **pkg, char *norewind)
295 {
296 struct dstoc *tail, *toc_pt;
297 char *ret;
298 char cmd[CMDSIZ];
299 char line[LSIZE+1];
300 int i, n, count = 0, header_size = BLK_SIZE;
301
302 if (!ds_header) { /* If the header hasn't been read yet */
303 if (ds_fd >= 0)
304 (void) ds_close(0);
305
306 /* always start with rewind device */
307 if ((ds_fd = open(device, O_RDONLY)) < 0) {
308 progerr(pkg_gt(ERR_UNPACK));
309 logerr(pkg_gt(MSG_OPEN), device, errno);
310 return (-1);
311 }
312
313 /* allocate room for the header equivalent to a block */
314 if ((ds_header = (char *)calloc(BLK_SIZE, 1)) == NULL) {
315 progerr(pkg_gt(ERR_UNPACK));
316 logerr(pkg_gt(MSG_MEM));
317 return (-1);
318 }
319
320 /* initialize the device */
321 if (ds_ginit(device) < 0) {
322 (void) ds_close(0);
323 progerr(pkg_gt(ERR_UNPACK));
324 logerr(pkg_gt(MSG_OPEN), device, errno);
325 return (-1);
326 }
327
328 /* read a logical block from the source device */
329 if (read(ds_fd, ds_header, BLK_SIZE) != BLK_SIZE) {
330 rpterr();
331 progerr(pkg_gt(ERR_UNPACK));
332 logerr(pkg_gt(MSG_TOC));
333 (void) ds_close(0);
334 return (-1);
335 }
336
337 /*
338 * This loop scans the medium for the start of the header.
339 * If the above read worked, we skip this. If it did't, this
340 * loop will retry the read ten times looking for the header
341 * marker string.
342 */
343 while (strncmp(ds_header, HDR_PREFIX, 20) != 0) {
344 /* only ten tries iff the device rewinds */
345 if (!norewind || count++ > 10) {
346 progerr(pkg_gt(ERR_UNPACK));
347 logerr(pkg_gt(MSG_TOC));
348 (void) ds_close(0);
349 return (-1);
350 }
351
352 /* read through to the last block */
353 if (count > 1)
354 while (read(ds_fd, ds_header, BLK_SIZE) > 0)
355 ;
356
357 /* then close the device */
358 (void) ds_close(0);
359
360 /* and reopen it */
361 if ((ds_fd = open(norewind, O_RDONLY)) < 0) {
362 progerr(pkg_gt(ERR_UNPACK));
363 logerr(pkg_gt(MSG_OPEN), device, errno);
364 (void) free(ds_header);
365 return (-1);
366 }
367
368 /* initialize the device */
369 if (ds_ginit(device) < 0) {
370 (void) ds_close(0);
371 progerr(pkg_gt(ERR_UNPACK));
372 logerr(pkg_gt(MSG_OPEN), device, errno);
373 return (-1);
374 }
375
376 /* read the block again */
377 if (read(ds_fd, ds_header, BLK_SIZE) != BLK_SIZE) {
378 rpterr();
379 progerr(pkg_gt(ERR_UNPACK));
380 logerr(pkg_gt(MSG_TOC));
381 (void) ds_close(0);
382 return (-1);
383 }
384 }
385
386 /* Now keep scanning until the whole header is in place. */
387 while (strstr(ds_header, HDR_SUFFIX) == NULL) {
388 /* We need a bigger buffer */
389 if ((ds_header = (char *)realloc(ds_header,
390 header_size + BLK_SIZE)) == NULL) {
391 progerr(pkg_gt(ERR_UNPACK));
392 logerr(pkg_gt(MSG_MEM));
393 (void) ds_close(0);
394 return (1);
395 }
396
397 /* clear the new memory */
398 (void) memset(ds_header + header_size, '\0',
399 BLK_SIZE);
400
401
402 /* read a logical block from the source device */
403 if (read(ds_fd, ds_header + header_size, BLK_SIZE) !=
404 BLK_SIZE) {
405 rpterr();
406 progerr(pkg_gt(ERR_UNPACK));
407 logerr(pkg_gt(MSG_TOC));
408 (void) ds_close(0);
409 return (-1);
410 } else
411 header_size += BLK_SIZE; /* new size */
412 }
413
414 /*
415 * remember rewind device for ds_close to rewind at
416 * close
417 */
418 if (count >= 1)
419 ds_device = device;
420 ds_headsize = header_size;
421
422 }
423
424 pds_header = ds_header;
425
426 /* read datastream table of contents */
427 ds_head = tail = (struct dstoc *)0;
428 ds_volcnt = 1;
429
430 while (ret = ds_gets(line, LSIZE)) {
431 if (strcmp(line, HDR_SUFFIX) == 0)
432 break;
433 if (!line[0] || line[0] == '#')
434 continue;
435 toc_pt = (struct dstoc *)calloc(1, sizeof (struct dstoc));
436 if (!toc_pt) {
437 progerr(pkg_gt(ERR_UNPACK));
438 logerr(pkg_gt(MSG_MEM));
439 ecleanup();
440 (void) free(ds_header);
441 return (-1);
442 }
443 /* LINTED E_SEC_SCANF_UNBOUNDED_COPY */
444 if (sscanf(line, "%s %d %d %[ 0-9]", toc_pt->pkg,
445 &toc_pt->nparts, &toc_pt->maxsiz, toc_pt->volnos) < 3) {
446 progerr(pkg_gt(ERR_UNPACK));
447 logerr(pkg_gt(MSG_TOC));
448 free(toc_pt);
449 (void) free(ds_header);
450 ecleanup();
451 return (-1);
452 }
453 if (tail) {
454 tail->next = toc_pt;
455 tail = toc_pt;
456 } else
457 ds_head = tail = toc_pt;
458 ds_volcnt += ds_volsum(toc_pt);
459 }
460 if (!ret) {
461 progerr(pkg_gt(ERR_UNPACK));
462 logerr(pkg_gt(MSG_TOC));
463 (void) free(ds_header);
464 return (-1);
465 }
466 (void) sighold(SIGINT);
467 (void) sigrelse(SIGINT);
468 if (!ds_head) {
469 progerr(pkg_gt(ERR_UNPACK));
470 logerr(pkg_gt(MSG_EMPTY));
471 (void) free(ds_header);
472 return (-1);
473 }
474 /* this could break, thanks to cpio command limit */
475 (void) snprintf(cmd, sizeof (cmd), "%s -icdumD -C %d",
476 CPIOPROC, (int)BLK_SIZE);
477 n = 0;
478 for (i = 0; pkg[i]; i++) {
479 if (strcmp(pkg[i], "all") == 0)
480 continue;
481 if (n == 0) {
482 (void) strlcat(cmd, " ", CMDSIZ);
483 n = 1;
484 }
485 (void) strlcat(cmd, pkg[i], CMDSIZ);
486 (void) strlcat(cmd, "'/*' ", CMDSIZ);
487 (void) strlcat(cmd, " ", CMDSIZ);
488 }
489
490 if (n = esystem(cmd, ds_fd, -1)) {
491 rpterr();
492 progerr(pkg_gt(ERR_UNPACK));
493 logerr(pkg_gt(MSG_CMDFAIL), cmd, n);
494 (void) free(ds_header);
495 return (-1);
496 }
497
498 ds_toc = ds_head;
499 ds_totread = 0;
500 ds_volno = 1;
501 return (0);
502 }
503
504 int
ds_findpkg(char * device,char * pkg)505 ds_findpkg(char *device, char *pkg)
506 {
507 char *pkglist[2];
508 int nskip, ods_volpart;
509
510 if (ds_head == NULL) {
511 pkglist[0] = pkg;
512 pkglist[1] = NULL;
513 if (ds_init(device, pkglist, NULL))
514 return (-1);
515 }
516
517 if (!pkg || pkgnmchk(pkg, "all", 0)) {
518 progerr(pkg_gt(ERR_UNPACK));
519 logerr(pkg_gt(MSG_PKGNAME));
520 return (-1);
521 }
522
523 nskip = 0;
524 ds_volno = 1;
525 ds_volpart = 0;
526 ds_toc = ds_head;
527 while (ds_toc) {
528 if (strcmp(ds_toc->pkg, pkg) == 0)
529 break;
530 nskip += ds_toc->nparts;
531 ds_volno += ds_volsum(ds_toc);
532 ds_toc = ds_toc->next;
533 }
534 if (!ds_toc) {
535 progerr(pkg_gt(ERR_UNPACK));
536 logerr(pkg_gt(MSG_NOPKG), pkg);
537 return (-1);
538 }
539
540 ds_pkginit();
541 ds_skippart = 0;
542 if (ds_curpartcnt > 0) {
543 ods_volpart = ds_volpart;
544 /*
545 * skip past archives belonging to last package on current
546 * volume
547 */
548 if (ds_volpart > 0 && ds_getnextvol(device))
549 return (-1);
550 ds_totread = nskip - ods_volpart;
551 if (ds_skip(device, ods_volpart))
552 return (-1);
553 } else if (ds_curpartcnt < 0) {
554 if (ds_skip(device, nskip - ds_totread))
555 return (-1);
556 } else
557 ds_totread = nskip;
558 ds_read = 0;
559 return (ds_nparts);
560 }
561
562 /*
563 * Get datastream part
564 * Call for first part should be preceded by
565 * call to ds_findpkg
566 */
567
568 int
ds_getpkg(char * device,int n,char * dstdir)569 ds_getpkg(char *device, int n, char *dstdir)
570 {
571 struct statvfs64 svfsb;
572 u_longlong_t free_blocks;
573
574 if (ds_read >= ds_nparts)
575 return (2);
576
577 if (ds_read == n)
578 return (0);
579 else if ((ds_read > n) || (n > ds_nparts))
580 return (2);
581
582 if (ds_maxsiz > 0) {
583 if (statvfs64(".", &svfsb)) {
584 progerr(pkg_gt(ERR_UNPACK));
585 logerr(pkg_gt(MSG_STATFS), errno);
586 return (-1);
587 }
588 free_blocks = (((long)svfsb.f_frsize > 0) ?
589 howmany(svfsb.f_frsize, DEV_BSIZE) :
590 howmany(svfsb.f_bsize, DEV_BSIZE)) * svfsb.f_bfree;
591 if ((ds_maxsiz + 50) > free_blocks) {
592 progerr(pkg_gt(ERR_UNPACK));
593 logerr(pkg_gt(MSG_NOSPACE), ds_maxsiz+50, free_blocks);
594 return (-1);
595 }
596 }
597 return (ds_next(device, dstdir));
598 }
599
600 static int
ds_getnextvol(char * device)601 ds_getnextvol(char *device)
602 {
603 char prompt[128];
604 int n;
605
606 if (ds_close(0))
607 return (-1);
608 (void) sprintf(prompt,
609 pkg_gt("Insert %%v %d of %d into %%p"),
610 ds_volno, ds_volcnt);
611 if (n = getvol(device, NULL, 0, prompt))
612 return (n);
613 if ((ds_fd = open(device, O_RDONLY)) < 0)
614 return (-1);
615 if (ds_ginit(device) < 0) {
616 (void) ds_close(0);
617 return (-1);
618 }
619 ds_volpart = 0;
620 return (0);
621 }
622
623 /*
624 * called by ds_findpkg to skip past archives for unwanted packages
625 * in current volume
626 */
627 static int
ds_skip(char * device,int nskip)628 ds_skip(char *device, int nskip)
629 {
630 char cmd[CMDSIZ];
631 int n, onskip = nskip;
632
633 while (nskip--) {
634 /* skip this one */
635 (void) snprintf(cmd, sizeof (cmd),
636 "%s -ictD -C %d > /dev/null", CPIOPROC, (int)BLK_SIZE);
637 if (n = esystem(cmd, ds_fd, -1)) {
638 rpterr();
639 progerr(pkg_gt(ERR_UNPACK));
640 logerr(pkg_gt(MSG_CMDFAIL), cmd, n);
641 nskip = onskip;
642 if (ds_volno == 1 || ds_volpart > 0)
643 return (n);
644 if (n = ds_getnextvol(device))
645 return (n);
646 }
647 }
648 ds_totread += onskip;
649 ds_volpart = onskip;
650 ds_skippart = onskip;
651 return (0);
652 }
653
654 /* skip to end of package if necessary */
655 void
ds_skiptoend(char * device)656 ds_skiptoend(char *device)
657 {
658 if (ds_read < ds_nparts && ds_curpartcnt < 0)
659 (void) ds_skip(device, ds_nparts - ds_read);
660 }
661
662 int
ds_next(char * device,char * instdir)663 ds_next(char *device, char *instdir)
664 {
665 char cmd[CMDSIZ], tmpvol[128];
666 int nparts, n, index;
667
668 /*CONSTCOND*/
669 while (1) {
670 if (ds_read + 1 > ds_curpartcnt && ds_curpartcnt >= 0) {
671 ds_volno++;
672 if (n = ds_getnextvol(device))
673 return (n);
674 (void) sscanf(ds_volnos, "%d %[ 0-9]", &index, tmpvol);
675 (void) strcpy(ds_volnos, tmpvol);
676 ds_curpartcnt += index;
677 }
678 (void) snprintf(cmd, sizeof (cmd), "%s -icdumD -C %d",
679 CPIOPROC, (int)BLK_SIZE);
680 if (n = esystem(cmd, ds_fd, -1)) {
681 rpterr();
682 progerr(pkg_gt(ERR_UNPACK));
683 logerr(pkg_gt(MSG_CMDFAIL), cmd, n);
684 }
685 if (ds_read == 0)
686 nparts = 0;
687 else
688 nparts = ds_toc->nparts;
689 if (n || (n = ckvolseq(instdir, ds_read + 1, nparts))) {
690 if (ds_volno == 1 || ds_volpart > ds_skippart)
691 return (-1);
692
693 if (n = ds_getnextvol(device))
694 return (n);
695 continue;
696 }
697 ds_read++;
698 ds_totread++;
699 ds_volpart++;
700
701 return (0);
702 }
703 /*NOTREACHED*/
704 }
705
706 /*
707 * ds_ginit: Determine the device being accessed, set the buffer size,
708 * and perform any device specific initialization.
709 */
710
711 int
ds_ginit(char * device)712 ds_ginit(char *device)
713 {
714 int oflag;
715 char *pbufsize, cmd[CMDSIZ];
716 int fd2, fd;
717
718 if ((pbufsize = devattr(device, "bufsize")) != NULL) {
719 ds_bufsize = atoi(pbufsize);
720 (void) free(pbufsize);
721 } else
722 ds_bufsize = BLK_SIZE;
723 oflag = fcntl(ds_fd, F_GETFL, 0);
724
725 if (ds_bufsize > BLK_SIZE) {
726 if (oflag & O_WRONLY)
727 fd = 1;
728 else
729 fd = 0;
730 fd2 = fcntl(fd, F_DUPFD, fd);
731 (void) close(fd);
732 (void) fcntl(ds_fd, F_DUPFD, fd);
733 if (fd)
734 (void) snprintf(cmd, sizeof (cmd),
735 "%s obs=%d 2>/dev/null", DDPROC, ds_bufsize);
736 else
737 (void) snprintf(cmd, sizeof (cmd),
738 "%s ibs=%d 2>/dev/null", DDPROC, ds_bufsize);
739 if ((ds_pp = popen(cmd, fd ? "w" : "r")) == NULL) {
740 progerr(pkg_gt(ERR_TRANSFER));
741 logerr(pkg_gt(MSG_POPEN), cmd, errno);
742 return (-1);
743 }
744 (void) close(fd);
745 (void) fcntl(fd2, F_DUPFD, fd);
746 (void) close(fd2);
747 ds_realfd = ds_fd;
748 ds_fd = fileno(ds_pp);
749 }
750 return (ds_bufsize);
751 }
752
753 int
ds_close(int pkgendflg)754 ds_close(int pkgendflg)
755 {
756 int n, ret = 0;
757
758 if (pkgendflg) {
759 if (ds_header)
760 (void) free(ds_header);
761 ds_header = (char *)NULL;
762 ds_totread = 0;
763 }
764
765 if (ds_pp) {
766 (void) pclose(ds_pp);
767 ds_pp = 0;
768 (void) close(ds_realfd);
769 ds_realfd = -1;
770 ds_fd = -1;
771 } else if (ds_fd >= 0) {
772 (void) close(ds_fd);
773 ds_fd = -1;
774 }
775
776 if (ds_device) {
777 /* rewind device */
778 if ((n = open(ds_device, 0)) >= 0)
779 (void) close(n);
780 ds_device = NULL;
781 }
782 return (ret);
783 }
784