usr.bin/split/split.c

   1 /*      $NetBSD: split.c,v 1.26 2011/09/16 15:39:29 joerg Exp $ */
   2
   3 /*
   4  * Copyright (c) 1987, 1993, 1994
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the University nor the names of its contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 #ifndef lint
  34 __COPYRIGHT("@(#) Copyright (c) 1987, 1993, 1994\
  35  The Regents of the University of California.  All rights reserved.");
  36 #endif /* not lint */
  37
  38 #ifndef lint
  39 #if 0
  40 static char sccsid[] = "@(#)split.c     8.3 (Berkeley) 4/25/94";
  41 #endif
  42 __RCSID("$NetBSD: split.c,v 1.26 2011/09/16 15:39:29 joerg Exp $");
  43 #endif /* not lint */
  44
  45 #include <sys/param.h>
  46
  47 #include <ctype.h>
  48 #include <err.h>
  49 #include <errno.h>
  50 #include <fcntl.h>
  51 #include <stdio.h>
  52 #include <stdlib.h>
  53 #include <string.h>
  54 #include <unistd.h>
  55
  56 #define DEFLINE 1000            /* Default num lines per file. */
  57
  58 static int file_open;           /* If a file open. */
  59 static int ifd = STDIN_FILENO, ofd = -1; /* Input/output file descriptors. */
  60 static char *fname;             /* File name prefix. */
  61 static size_t sfxlen = 2;               /* suffix length. */
  62
  63 static void newfile(void);
  64 static void split1(off_t, int) __dead;
  65 static void split2(off_t) __dead;
  66 static void split3(off_t) __dead;
  67 static void usage(void) __dead;
  68 static size_t bigwrite(int, void const *, size_t);
  69
  70 int
  71 main(int argc, char *argv[])
  72 {
  73         int ch;
  74         char *ep, *p;
  75         char const *base;
  76         off_t bytecnt = 0;      /* Byte count to split on. */
  77         off_t numlines = 0;     /* Line count to split on. */
  78         off_t chunks = 0;       /* Number of chunks to split into. */
  79
  80         while ((ch = getopt(argc, argv, "0123456789b:l:a:n:")) != -1)
  81                 switch (ch) {
  82                 case '0': case '1': case '2': case '3': case '4':
  83                 case '5': case '6': case '7': case '8': case '9':
  84                         /*
  85                          * Undocumented kludge: split was originally designed
  86                          * to take a number after a dash.
  87                          */
  88                         if (numlines == 0) {
  89                                 p = argv[optind - 1];
  90                                 if (p[0] == '-' && p[1] == ch && !p[2])
  91                                         p++;
  92                                 else
  93                                         p = argv[optind] + 1;
  94                                 numlines = strtoull(p, &ep, 10);
  95                                 if (numlines == 0 || *ep != '\0')
  96                                         errx(1, "%s: illegal line count.", p);
  97                         }
  98                         break;
  99                 case 'b':               /* Byte count. */
 100                         if (!isdigit((unsigned char)optarg[0]) ||
 101                             (bytecnt = strtoull(optarg, &ep, 10)) == 0 ||
 102                             (*ep != '\0' && *ep != 'k' && *ep != 'm'))
 103                                 errx(1, "%s: illegal byte count.", optarg);
 104                         if (*ep == 'k')
 105                                 bytecnt *= 1024;
 106                         else if (*ep == 'm')
 107                                 bytecnt *= 1024 * 1024;
 108                         break;
 109                 case 'l':               /* Line count. */
 110                         if (numlines != 0)
 111                                 usage();
 112                         if (!isdigit((unsigned char)optarg[0]) ||
 113                             (numlines = strtoull(optarg, &ep, 10)) == 0 ||
 114                             *ep != '\0')
 115                                 errx(1, "%s: illegal line count.", optarg);
 116                         break;
 117                 case 'a':               /* Suffix length. */
 118                         if (!isdigit((unsigned char)optarg[0]) ||
 119                             (sfxlen = (size_t)strtoul(optarg, &ep, 10)) == 0 ||
 120                             *ep != '\0')
 121                                 errx(1, "%s: illegal suffix length.", optarg);
 122                         break;
 123                 case 'n':               /* Chunks. */
 124                         if (!isdigit((unsigned char)optarg[0]) ||
 125                             (chunks = (size_t)strtoul(optarg, &ep, 10)) == 0 ||
 126                             *ep != '\0')
 127                                 errx(1, "%s: illegal number of chunks.", optarg);
 128                         break;
 129                 default:
 130                         usage();
 131                 }
 132         argv += optind;
 133         argc -= optind;
 134
 135         if (*argv != NULL) {
 136                 if (strcmp(*argv, "-") != 0 &&
 137                     (ifd = open(*argv, O_RDONLY, 0)) < 0)
 138                         err(1, "%s", *argv);
 139                 ++argv;
 140         }
 141
 142
 143         base = (*argv != NULL) ? *argv++ : "x";
 144         if ((fname = malloc(strlen(base) + sfxlen + 1)) == NULL)
 145                 err(EXIT_FAILURE, NULL);
 146         (void)strcpy(fname, base);              /* File name prefix. */
 147
 148         if (*argv != NULL)
 149                 usage();
 150
 151         if (numlines == 0)
 152                 numlines = DEFLINE;
 153         else if (bytecnt || chunks)
 154                 usage();
 155
 156         if (bytecnt && chunks)
 157                 usage();
 158
 159         if (bytecnt)
 160                 split1(bytecnt, 0);
 161         else if (chunks)
 162                 split3(chunks);
 163         else
 164                 split2(numlines);
 165
 166         return 0;
 167 }
 168
 169 /*
 170  * split1 --
 171  *      Split the input by bytes.
 172  */
 173 static void
 174 split1(off_t bytecnt, int maxcnt)
 175 {
 176         off_t bcnt;
 177         ssize_t dist, len;
 178         char *C;
 179         char bfr[MAXBSIZE];
 180         int nfiles;
 181
 182         nfiles = 0;
 183
 184         for (bcnt = 0;;)
 185                 switch (len = read(ifd, bfr, MAXBSIZE)) {
 186                 case 0:
 187                         exit(0);
 188                         /* NOTREACHED */
 189                 case -1:
 190                         err(1, "read");
 191                         /* NOTREACHED */
 192                 default:
 193                         if (!file_open) {
 194                                 if (!maxcnt || (nfiles < maxcnt)) {
 195                                         newfile();
 196                                         nfiles++;
 197                                         file_open = 1;
 198                                 }
 199                         }
 200                         if (bcnt + len >= bytecnt) {
 201                                 /* LINTED: bytecnt - bcnt <= len */
 202                                 dist = bytecnt - bcnt;
 203                                 if (bigwrite(ofd, bfr, dist) != (size_t)dist)
 204                                         err(1, "write");
 205                                 len -= dist;
 206                                 for (C = bfr + dist; len >= bytecnt;
 207                                     /* LINTED: bytecnt <= len */
 208                                     len -= bytecnt, C += bytecnt) {
 209                                         if (!maxcnt || (nfiles < maxcnt)) {
 210                                                 newfile();
 211                                                 nfiles++;
 212                                         }
 213                                         /* LINTED: as above */
 214                                         if (bigwrite(ofd,
 215                                             C, bytecnt) != (size_t)bytecnt)
 216                                                 err(1, "write");
 217                                 }
 218                                 if (len) {
 219                                         if (!maxcnt || (nfiles < maxcnt)) {
 220                                                 newfile();
 221                                                 nfiles++;
 222                                         }
 223                                         /* LINTED: len >= 0 */
 224                                         if (bigwrite(ofd, C, len) != (size_t)len)
 225                                                 err(1, "write");
 226                                 } else
 227                                         file_open = 0;
 228                                 bcnt = len;
 229                         } else {
 230                                 bcnt += len;
 231                                 /* LINTED: len >= 0 */
 232                                 if (bigwrite(ofd, bfr, len) != (size_t)len)
 233                                         err(1, "write");
 234                         }
 235                 }
 236 }
 237
 238 /*
 239  * split2 --
 240  *      Split the input by lines.
 241  */
 242 static void
 243 split2(off_t numlines)
 244 {
 245         off_t lcnt;
 246         size_t bcnt;
 247         ssize_t len;
 248         char *Ce, *Cs;
 249         char bfr[MAXBSIZE];
 250
 251         for (lcnt = 0;;)
 252                 switch (len = read(ifd, bfr, MAXBSIZE)) {
 253                 case 0:
 254                         exit(0);
 255                         /* NOTREACHED */
 256                 case -1:
 257                         err(1, "read");
 258                         /* NOTREACHED */
 259                 default:
 260                         if (!file_open) {
 261                                 newfile();
 262                                 file_open = 1;
 263                         }
 264                         for (Cs = Ce = bfr; len--; Ce++)
 265                                 if (*Ce == '\n' && ++lcnt == numlines) {
 266                                         bcnt = Ce - Cs + 1;
 267                                         if (bigwrite(ofd, Cs, bcnt) != (size_t)bcnt)
 268                                                 err(1, "write");
 269                                         lcnt = 0;
 270                                         Cs = Ce + 1;
 271                                         if (len)
 272                                                 newfile();
 273                                         else
 274                                                 file_open = 0;
 275                                 }
 276                         if (Cs < Ce) {
 277                                 bcnt = Ce - Cs;
 278                                 if (bigwrite(ofd, Cs, bcnt) != (size_t)bcnt)
 279                                         err(1, "write");
 280                         }
 281                 }
 282 }
 283
 284 /*
 285  * split3 --
 286  *      Split the input into specified number of chunks
 287  */
 288 static void
 289 split3(off_t chunks)
 290 {
 291         struct stat sb;
 292
 293         if (fstat(ifd, &sb) == -1) {
 294                 err(1, "stat");
 295                 /* NOTREACHED */
 296         }
 297
 298         if (chunks > sb.st_size) {
 299                 errx(1, "can't split into more than %d files",
 300                                 (int)sb.st_size);
 301                 /* NOTREACHED */
 302         }
 303
 304         split1(sb.st_size/chunks, chunks);
 305 }
 306
 307 /*
 308  * newfile --
 309  *      Open a new output file.
 310  */
 311 static void
 312 newfile(void)
 313 {
 314         static int fnum;
 315         static char *fpnt;
 316         int quot, i;
 317
 318         if (ofd == -1) {
 319                 fpnt = fname + strlen(fname);
 320                 fpnt[sfxlen] = '\0';
 321         } else if (close(ofd) != 0)
 322                 err(1, "%s", fname);
 323
 324         quot = fnum;
 325         for (i = sfxlen - 1; i >= 0; i--) {
 326                 fpnt[i] = quot % 26 + 'a';
 327                 quot = quot / 26;
 328         }
 329         if (quot > 0)
 330                 errx(1, "too many files.");
 331         ++fnum;
 332         if ((ofd = open(fname, O_WRONLY | O_CREAT | O_TRUNC, DEFFILEMODE)) < 0)
 333                 err(1, "%s", fname);
 334 }
 335
 336 static size_t
 337 bigwrite(int fd, const void *buf, size_t len)
 338 {
 339         const char *ptr = buf;
 340         size_t sofar = 0;
 341         ssize_t w;
 342
 343         while (len != 0) {
 344                 if  ((w = write(fd, ptr, len)) == -1)
 345                         return sofar;
 346                 len -= w;
 347                 ptr += w;
 348                 sofar += w;
 349         }
 350         return sofar;
 351 }
 352
 353
 354 static void
 355 usage(void)
 356 {
 357         (void)fprintf(stderr,
 358 "usage: %s [-b byte_count] [-l line_count] [-n chunk_count] [-a suffix_length] "
 359 "[file [prefix]]\n", getprogname());
 360         exit(1);
 361 }