/* * Convert fixed length (cbsz) records to variable length. Deletes any * trailing blanks and appends a newline. * * max in buffer: MAX(ibs, cbsz) + cbsz * max out buffer: obs + cbsz */ void unblock(rtems_shell_dd_globals* globals) { u_char *inp; const u_char *t; size_t cnt; /* Translation and case conversion. */ if ((t = ctab) != NULL) for (inp = in.dbp - (cnt = in.dbrcnt); cnt--; ++inp) *inp = t[*inp]; /* * Copy records (max cbsz size chunks) into the output buffer. The * translation has to already be done or we might not recognize the * spaces. */ for (inp = in.db; in.dbcnt >= cbsz; inp += cbsz, in.dbcnt -= cbsz) { for (t = inp + cbsz - 1; t >= inp && *t == ' '; --t) ; if (t >= inp) { cnt = t - inp + 1; (void)memmove(out.dbp, inp, cnt); out.dbp += cnt; out.dbcnt += cnt; } *out.dbp++ = '\n'; if (++out.dbcnt >= out.dbsz) dd_out(globals, 0); } if (in.dbcnt) (void)memmove(in.db, in.dbp - in.dbcnt, in.dbcnt); in.dbp = in.db + in.dbcnt; }
/* * def -- * Copy input to output. Input is buffered until reaches obs, and then * output until less than obs remains. Only a single buffer is used. * Worst case buffer calculation is (ibs + obs - 1). */ void def(rtems_shell_dd_globals* globals) { u_char *inp; const u_char *t; size_t cnt; if ((t = ctab) != NULL) for (inp = in.dbp - (cnt = in.dbrcnt); cnt--; ++inp) *inp = t[*inp]; /* Make the output buffer look right. */ out.dbp = in.dbp; out.dbcnt = in.dbcnt; if (in.dbcnt >= out.dbsz) { /* If the output buffer is full, write it. */ dd_out(globals, 0); /* * Ddout copies the leftover output to the beginning of * the buffer and resets the output buffer. Reset the * input buffer to match it. */ in.dbp = out.dbp; in.dbcnt = out.dbcnt; } }
/* * def -- * Copy input to output. Input is buffered until reaches obs, and then * output until less than obs remains. Only a single buffer is used. * Worst case buffer calculation is (ibs + obs - 1). */ void def() { int cnt; u_char *inp, *t; if (t = ctab) for (inp = in.dbp - (cnt = in.dbrcnt); cnt--; ++inp) *inp = t[*inp]; /* Make the output buffer look right. */ out.dbp = in.dbp; out.dbcnt = in.dbcnt; if (in.dbcnt >= out.dbsz) { /* If the output buffer is full, write it. */ dd_out(0); /* * Ddout copies the leftover output to the beginning of * the buffer and resets the output buffer. Reset the * input buffer to match it. */ in.dbp = out.dbp; in.dbcnt = out.dbcnt; } }
/* * Convert fixed length (cbsz) records to variable length. Deletes any * trailing blanks and appends a newline. * * max in buffer: MAX(ibs, cbsz) + cbsz * max out buffer: obs + cbsz */ void unblock() { int cnt; u_char *inp, *t; /* Translation and case conversion. */ if (t = ctab) for (cnt = in.dbrcnt, inp = in.dbp; cnt--;) *--inp = t[*inp]; /* * Copy records (max cbsz size chunks) into the output buffer. The * translation has to already be done or we might not recognize the * spaces. */ for (inp = in.db; in.dbcnt >= cbsz; inp += cbsz, in.dbcnt -= cbsz) { for (t = inp + cbsz - 1; t >= inp && *t == ' '; --t); if (t >= inp) { cnt = t - inp + 1; memmove(out.dbp, inp, cnt); out.dbp += cnt; out.dbcnt += cnt; } ++out.dbcnt; *out.dbp++ = '\n'; if (out.dbcnt >= out.dbsz) dd_out(0); } if (in.dbcnt) memmove(in.db, in.dbp - in.dbcnt, in.dbcnt); in.dbp = in.db + in.dbcnt; }
/* * Cleanup any remaining I/O and flush output. If necesssary, output file * is truncated. */ static void dd_close(void) { if (cfunc == def) def_close(); else if (cfunc == block) block_close(); else if (cfunc == unblock) unblock_close(); if (ddflags & C_OSYNC && out.dbcnt < out.dbsz) { (void)memset(out.dbp, 0, out.dbsz - out.dbcnt); out.dbcnt = out.dbsz; } /* If there are pending sparse blocks, make sure * to write out the final block un-sparse */ if ((out.dbcnt == 0) && pending) { memset(out.db, 0, out.dbsz); out.dbcnt = out.dbsz; out.dbp = out.db + out.dbcnt; pending -= out.dbsz; } if (out.dbcnt) dd_out(1); /* * Reporting nfs write error may be defered until next * write(2) or close(2) system call. So, we need to do an * extra check. If an output is stdout, the file structure * may be shared among with other processes and close(2) just * decreases the reference count. */ if (out.fd == STDOUT_FILENO && fsync(out.fd) == -1 && errno != EINVAL) { fprintf(stderr, "fsync stdout: %s\n", strerror(errno)); exit(1); /* NOTREACHED */ } if (close(out.fd) == -1) { fprintf(stderr, "close: %s\n", strerror(errno)); exit(1); /* NOTREACHED */ } }
/* * Cleanup any remaining I/O and flush output. If necessary, output file * is truncated. */ static void dd_close(void) { if (cfunc == def) def_close(); else if (cfunc == block) block_close(); else if (cfunc == unblock) unblock_close(); if (ddflags & C_OSYNC && out.dbcnt && out.dbcnt < out.dbsz) { if (ddflags & (C_BLOCK|C_UNBLOCK)) memset(out.dbp, ' ', out.dbsz - out.dbcnt); else memset(out.dbp, 0, out.dbsz - out.dbcnt); out.dbcnt = out.dbsz; } if (out.dbcnt) dd_out(1); }
static void dd_in(void) { int flags; int64_t n; for (flags = ddflags;;) { if (cpy_cnt && (st.in_full + st.in_part) >= cpy_cnt) return; /* * Clear the buffer first if doing "sync" on input. * If doing block operations use spaces. This will * affect not only the C_NOERROR case, but also the * last partial input block which should be padded * with zero and not garbage. */ if (flags & C_SYNC) { if (flags & (C_BLOCK|C_UNBLOCK)) (void)memset(in.dbp, ' ', in.dbsz); else (void)memset(in.dbp, 0, in.dbsz); } n = read(in.fd, in.dbp, in.dbsz); if (n == 0) { in.dbrcnt = 0; return; } /* Read error. */ if (n < 0) { /* * If noerror not specified, die. POSIX requires that * the warning message be followed by an I/O display. */ if (!(flags & C_NOERROR)) { err(EXIT_FAILURE, "%s", in.name); /* NOTREACHED */ } warn("%s", in.name); summary(); /* * If it's not a tape drive or a pipe, seek past the * error. If your OS doesn't do the right thing for * raw disks this section should be modified to re-read * in sector size chunks. */ if (!(in.flags & (ISPIPE|ISTAPE)) && lseek(in.fd, (off_t)in.dbsz, SEEK_CUR)) warn("%s", in.name); /* If sync not specified, omit block and continue. */ if (!(ddflags & C_SYNC)) continue; /* Read errors count as full blocks. */ in.dbcnt += in.dbrcnt = in.dbsz; ++st.in_full; /* Handle full input blocks. */ } else if (n == in.dbsz) { in.dbcnt += in.dbrcnt = n; ++st.in_full; /* Handle partial input blocks. */ } else { /* If sync, use the entire block. */ if (ddflags & C_SYNC) in.dbcnt += in.dbrcnt = in.dbsz; else in.dbcnt += in.dbrcnt = n; ++st.in_part; } /* * POSIX states that if bs is set and no other conversions * than noerror, notrunc or sync are specified, the block * is output without buffering as it is read. */ if (ddflags & C_BS) { out.dbcnt = in.dbcnt; dd_out(1); in.dbcnt = 0; continue; } if (ddflags & C_SWAB) { if ((n = in.dbrcnt) & 1) { ++st.swab; --n; } swab(in.dbp, in.dbp, n); } in.dbp += in.dbrcnt; (*cfunc)(); } }
/* * Copy variable length newline terminated records with a max size cbsz * bytes to output. Records less than cbs are padded with spaces. * * max in buffer: MAX(ibs, cbsz) * max out buffer: obs + cbsz */ void block(rtems_shell_dd_globals* globals) { u_char *inp, *outp; const u_char *t; size_t cnt, maxlen; static int intrunc; int ch; /* * Record truncation can cross block boundaries. If currently in a * truncation state, keep tossing characters until reach a newline. * Start at the beginning of the buffer, as the input buffer is always * left empty. */ if (intrunc) { for (inp = in.db, cnt = in.dbrcnt; cnt && *inp++ != '\n'; --cnt) ; if (!cnt) { in.dbcnt = 0; in.dbp = in.db; return; } intrunc = 0; /* Adjust the input buffer numbers. */ in.dbcnt = cnt - 1; in.dbp = inp + cnt - 1; } /* * Copy records (max cbsz size chunks) into the output buffer. The * translation is done as we copy into the output buffer. */ ch = 0; for (inp = in.dbp - in.dbcnt, outp = out.dbp; in.dbcnt;) { maxlen = MIN(cbsz, in.dbcnt); if ((t = ctab) != NULL) for (cnt = 0; cnt < maxlen && (ch = *inp++) != '\n'; ++cnt) *outp++ = t[ch]; else for (cnt = 0; cnt < maxlen && (ch = *inp++) != '\n'; ++cnt) *outp++ = ch; /* * Check for short record without a newline. Reassemble the * input block. */ if (ch != '\n' && in.dbcnt < cbsz) { (void)memmove(in.db, in.dbp - in.dbcnt, in.dbcnt); break; } /* Adjust the input buffer numbers. */ in.dbcnt -= cnt; if (ch == '\n') --in.dbcnt; /* Pad short records with spaces. */ if (cnt < cbsz) (void)memset(outp, ctab ? ctab[' '] : ' ', cbsz - cnt); else { /* * If the next character wouldn't have ended the * block, it's a truncation. */ if (!in.dbcnt || *inp != '\n') ++st.trunc; /* Toss characters to a newline. */ for (; in.dbcnt && *inp++ != '\n'; --in.dbcnt) ; if (!in.dbcnt) intrunc = 1; else --in.dbcnt; } /* Adjust output buffer numbers. */ out.dbp += cbsz; if ((out.dbcnt += cbsz) >= out.dbsz) dd_out(globals, 0); outp = out.dbp; } in.dbp = in.db + in.dbcnt; }
static void getfdtype(IO *io) { struct stat sb; int type; if (fstat(io->fd, &sb) == -1) err(1, "%s", io->name); if (S_ISREG(sb.st_mode)) io->flags |= ISTRUNC; if (S_ISCHR(sb.st_mode) || S_ISBLK(sb.st_mode)) { if (ioctl(io->fd, FIODTYPE, &type) == -1) { err(1, "%s", io->name); } else { if (type & D_TAPE) io->flags |= ISTAPE; #ifdef __APPLE__ else if (type & D_DISK) { #else else if (type & (D_DISK | D_MEM)) { if (type & D_DISK) { const int one = 1; (void)ioctl(io->fd, DIOCWLABEL, &one); } #endif io->flags |= ISSEEK; } if (S_ISCHR(sb.st_mode) && (type & D_TAPE) == 0) io->flags |= ISCHR; } return; } errno = 0; if (lseek(io->fd, (off_t)0, SEEK_CUR) == -1 && errno == ESPIPE) io->flags |= ISPIPE; else io->flags |= ISSEEK; } static void dd_in(void) { ssize_t n; for (;;) { switch (cpy_cnt) { case -1: /* count=0 was specified */ return; case 0: break; default: if (st.in_full + st.in_part >= (u_quad_t)cpy_cnt) return; break; } /* * Zero the buffer first if sync; if doing block operations, * use spaces. */ if (ddflags & C_SYNC) { if (ddflags & (C_BLOCK | C_UNBLOCK)) memset(in.dbp, ' ', in.dbsz); else memset(in.dbp, 0, in.dbsz); } n = read(in.fd, in.dbp, in.dbsz); if (n == 0) { in.dbrcnt = 0; return; } /* Read error. */ if (n == -1) { /* * If noerror not specified, die. POSIX requires that * the warning message be followed by an I/O display. */ if (!(ddflags & C_NOERROR)) err(1, "%s", in.name); warn("%s", in.name); summary(); /* * If it's a seekable file descriptor, seek past the * error. If your OS doesn't do the right thing for * raw disks this section should be modified to re-read * in sector size chunks. */ if (in.flags & ISSEEK && lseek(in.fd, (off_t)in.dbsz, SEEK_CUR)) warn("%s", in.name); /* If sync not specified, omit block and continue. */ if (!(ddflags & C_SYNC)) continue; /* Read errors count as full blocks. */ in.dbcnt += in.dbrcnt = in.dbsz; ++st.in_full; /* Handle full input blocks. */ } else if ((size_t)n == in.dbsz) { in.dbcnt += in.dbrcnt = n; ++st.in_full; /* Handle partial input blocks. */ } else { /* If sync, use the entire block. */ if (ddflags & C_SYNC) in.dbcnt += in.dbrcnt = in.dbsz; else in.dbcnt += in.dbrcnt = n; ++st.in_part; } /* * POSIX states that if bs is set and no other conversions * than noerror, notrunc or sync are specified, the block * is output without buffering as it is read. */ if (ddflags & C_BS) { out.dbcnt = in.dbcnt; dd_out(1); in.dbcnt = 0; continue; } if (ddflags & C_SWAB) { if ((n = in.dbrcnt) & 1) { ++st.swab; --n; } swab(in.dbp, in.dbp, (size_t)n); } in.dbp += in.dbrcnt; (*cfunc)(); } }