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) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25
26 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
27 /* All Rights Reserved */
28
29 /*
30 * Copyright (c) 2018, Joyent, Inc.
31 */
32
33 /*
34 * csplit - Context or line file splitter
35 * Compile: cc -O -s -o csplit csplit.c
36 */
37
38 #include <stdio.h>
39 #include <stdlib.h>
40 #include <unistd.h>
41 #include <string.h>
42 #include <ctype.h>
43 #include <errno.h>
44 #include <limits.h>
45 #include <regexpr.h>
46 #include <signal.h>
47 #include <locale.h>
48 #include <libintl.h>
49
50 #define LAST 0LL
51 #define ERR -1
52 #define FALSE 0
53 #define TRUE 1
54 #define EXPMODE 2
55 #define LINMODE 3
56 #define LINSIZ LINE_MAX /* POSIX.2 - read lines LINE_MAX long */
57
58 /* Globals */
59
60 char linbuf[LINSIZ]; /* Input line buffer */
61 char *expbuf;
62 char tmpbuf[BUFSIZ]; /* Temporary buffer for stdin */
63 char file[8192] = "xx"; /* File name buffer */
64 char *targ; /* Arg ptr for error messages */
65 char *sptr;
66 FILE *infile, *outfile; /* I/O file streams */
67 int silent, keep, create; /* Flags: -s(ilent), -k(eep), (create) */
68 int errflg;
69 int fiwidth = 2; /* file index width (output file names) */
70 extern int optind;
71 extern char *optarg;
72 offset_t offset; /* Regular expression offset value */
73 offset_t curline; /* Current line in input file */
74
75 /*
76 * These defines are needed for regexp handling(see regexp(7))
77 */
78 #define PERROR(x) fatal("%s: Illegal Regular Expression\n", targ);
79
80 static int asc_to_ll(char *, long long *);
81 static void closefile(void);
82 static void fatal(char *, char *);
83 static offset_t findline(char *, offset_t);
84 static void flush(void);
85 static FILE *getfile(void);
86 static char *getaline(int);
87 static void line_arg(char *);
88 static void num_arg(char *, int);
89 static void re_arg(char *);
90 static void sig(int);
91 static void to_line(offset_t);
92 static void usage(void);
93
94 int
95 main(int argc, char **argv)
96 {
97 int ch, mode;
98 char *ptr;
99
100 (void) setlocale(LC_ALL, "");
101 #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */
102 #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */
103 #endif
104 (void) textdomain(TEXT_DOMAIN);
105
106 while ((ch = getopt(argc, argv, "skf:n:")) != EOF) {
107 switch (ch) {
108 case 'f':
109 (void) strcpy(file, optarg);
110 if ((ptr = strrchr(optarg, '/')) == NULL)
111 ptr = optarg;
112 else
113 ptr++;
114
115 break;
116 case 'n': /* POSIX.2 */
117 for (ptr = optarg; *ptr != NULL; ptr++)
118 if (!isdigit((int)*ptr))
119 fatal("-n num\n", NULL);
120 fiwidth = atoi(optarg);
121 break;
122 case 'k':
123 keep++;
124 break;
125 case 's':
126 silent++;
127 break;
128 case '?':
129 errflg++;
130 }
131 }
132
133 argv = &argv[optind];
134 argc -= optind;
135 if (argc <= 1 || errflg)
136 usage();
137
138 if (strcmp(*argv, "-") == 0) {
139 infile = tmpfile();
140
141 while (fread(tmpbuf, 1, BUFSIZ, stdin) != 0) {
142 if (fwrite(tmpbuf, 1, BUFSIZ, infile) == 0)
143 if (errno == ENOSPC) {
144 (void) fprintf(stderr, "csplit: ");
145 (void) fprintf(stderr, gettext(
146 "No space left on device\n"));
147 exit(1);
148 } else {
149 (void) fprintf(stderr, "csplit: ");
150 (void) fprintf(stderr, gettext(
151 "Bad write to temporary "
152 "file\n"));
153 exit(1);
154 }
155
156 /* clear the buffer to get correct size when writing buffer */
157
158 (void) memset(tmpbuf, '\0', sizeof (tmpbuf));
159 }
160 rewind(infile);
161 } else if ((infile = fopen(*argv, "r")) == NULL)
162 fatal("Cannot open %s\n", *argv);
163 ++argv;
164 curline = (offset_t)1;
165 (void) signal(SIGINT, sig);
166
167 /*
168 * The following for loop handles the different argument types.
169 * A switch is performed on the first character of the argument
170 * and each case calls the appropriate argument handling routine.
171 */
172
173 for (; *argv; ++argv) {
174 targ = *argv;
175 switch (**argv) {
176 case '/':
177 mode = EXPMODE;
178 create = TRUE;
179 re_arg(*argv);
180 break;
181 case '%':
182 mode = EXPMODE;
183 create = FALSE;
184 re_arg(*argv);
185 break;
186 case '{':
187 num_arg(*argv, mode);
188 mode = FALSE;
189 break;
190 default:
191 mode = LINMODE;
192 create = TRUE;
193 line_arg(*argv);
194 break;
195 }
196 }
197 create = TRUE;
198 to_line(LAST);
199 return (0);
200 }
201
202 /*
203 * asc_to_ll takes an ascii argument(str) and converts it to a long long(plc)
204 * It returns ERR if an illegal character. The reason that asc_to_ll
205 * does not return an answer(long long) is that any value for the long
206 * long is legal, and this version of asc_to_ll detects error strings.
207 */
208
209 static int
210 asc_to_ll(char *str, long long *plc)
211 {
212 int f;
213 *plc = 0;
214 f = 0;
215 for (; ; str++) {
216 switch (*str) {
217 case ' ':
218 case '\t':
219 continue;
220 case '-':
221 f++;
222 /* FALLTHROUGH */
223 case '+':
224 str++;
225 }
226 break;
227 }
228 for (; *str != NULL; str++)
229 if (*str >= '0' && *str <= '9')
230 *plc = *plc * 10 + *str - '0';
231 else
232 return (ERR);
233 if (f)
234 *plc = -(*plc);
235 return (TRUE); /* not error */
236 }
237
238 /*
239 * Closefile prints the byte count of the file created,(via fseeko
240 * and ftello), if the create flag is on and the silent flag is not on.
241 * If the create flag is on closefile then closes the file(fclose).
242 */
243
244 static void
245 closefile()
246 {
247 if (!silent && create) {
248 (void) fseeko(outfile, (offset_t)0, SEEK_END);
249 (void) fprintf(stdout, "%lld\n", (offset_t)ftello(outfile));
250 }
251 if (create)
252 (void) fclose(outfile);
253 }
254
255 /*
256 * Fatal handles error messages and cleanup.
257 * Because "arg" can be the global file, and the cleanup processing
258 * uses the global file, the error message is printed first. If the
259 * "keep" flag is not set, fatal unlinks all created files. If the
260 * "keep" flag is set, fatal closes the current file(if there is one).
261 * Fatal exits with a value of 1.
262 */
263
264 static void
265 fatal(char *string, char *arg)
266 {
267 char *fls;
268 int num;
269
270 (void) fprintf(stderr, "csplit: ");
271
272 /* gettext dynamically replaces string */
273
274 (void) fprintf(stderr, gettext(string), arg);
275 if (!keep) {
276 if (outfile) {
277 (void) fclose(outfile);
278 for (fls = file; *fls != '\0'; fls++)
279 continue;
280 fls -= fiwidth;
281 for (num = atoi(fls); num >= 0; num--) {
282 (void) sprintf(fls, "%.*d", fiwidth, num);
283 (void) unlink(file);
284 }
285 }
286 } else
287 if (outfile)
288 closefile();
289 exit(1);
290 }
291
292 /*
293 * Findline returns the line number referenced by the current argument.
294 * Its arguments are a pointer to the compiled regular expression(expr),
295 * and an offset(oset). The variable lncnt is used to count the number
296 * of lines searched. First the current stream location is saved via
297 * ftello(), and getaline is called so that R.E. searching starts at the
298 * line after the previously referenced line. The while loop checks
299 * that there are more lines(error if none), bumps the line count, and
300 * checks for the R.E. on each line. If the R.E. matches on one of the
301 * lines the old stream location is restored, and the line number
302 * referenced by the R.E. and the offset is returned.
303 */
304
305 static offset_t
306 findline(char *expr, offset_t oset)
307 {
308 static int benhere = 0;
309 offset_t lncnt = 0, saveloc;
310
311 saveloc = ftello(infile);
312 if (curline != (offset_t)1 || benhere) /* If first line, first time, */
313 (void) getaline(FALSE); /* then don't skip */
314 else
315 lncnt--;
316 benhere = 1;
317 while (getaline(FALSE) != NULL) {
318 lncnt++;
319 if ((sptr = strrchr(linbuf, '\n')) != NULL)
320 *sptr = '\0';
321 if (step(linbuf, expr)) {
322 (void) fseeko(infile, (offset_t)saveloc, SEEK_SET);
323 return (curline+lncnt+oset);
324 }
325 }
326 (void) fseeko(infile, (offset_t)saveloc, SEEK_SET);
327 return (curline+lncnt+oset+2);
328 }
329
330 /*
331 * Flush uses fputs to put lines on the output file stream(outfile)
332 * Since fputs does its own buffering, flush doesn't need to.
333 * Flush does nothing if the create flag is not set.
334 */
335
336 static void
337 flush()
338 {
339 if (create)
340 (void) fputs(linbuf, outfile);
341 }
342
343 /*
344 * Getfile does nothing if the create flag is not set. If the create
345 * flag is set, getfile positions the file pointer(fptr) at the end of
346 * the file name prefix on the first call(fptr=0). The file counter is
347 * stored in the file name and incremented. If the subsequent fopen
348 * fails, the file name is copied to tfile for the error message, the
349 * previous file name is restored for cleanup, and fatal is called. If
350 * the fopen succeeds, the stream(opfil) is returned.
351 */
352
353 FILE *
354 getfile()
355 {
356 static char *fptr;
357 static int ctr;
358 FILE *opfil;
359 char tfile[15];
360 char *delim;
361 char savedelim;
362
363 if (create) {
364 if (fptr == 0)
365 for (fptr = file; *fptr != NULL; fptr++)
366 continue;
367 (void) sprintf(fptr, "%.*d", fiwidth, ctr++);
368
369 /* check for suffix length overflow */
370 if (strlen(fptr) > fiwidth) {
371 fatal("Suffix longer than %ld chars; increase -n\n",
372 (char *)fiwidth);
373 }
374
375 /* check for filename length overflow */
376
377 delim = strrchr(file, '/');
378 if (delim == (char *)NULL) {
379 if (strlen(file) > pathconf(".", _PC_NAME_MAX)) {
380 fatal("Name too long: %s\n", file);
381 }
382 } else {
383 /* truncate file at pathname delim to do pathconf */
384 savedelim = *delim;
385 *delim = '\0';
386 /*
387 * file: pppppppp\0fffff\0
388 * ..... ^ file
389 * ............. ^ delim
390 */
391 if (strlen(delim + 1) > pathconf(file, _PC_NAME_MAX)) {
392 fatal("Name too long: %s\n", delim + 1);
393 }
394 *delim = savedelim;
395 }
396
397 if ((opfil = fopen(file, "w")) == NULL) {
398 (void) strlcpy(tfile, file, sizeof (tfile));
399 (void) sprintf(fptr, "%.*d", fiwidth, (ctr-2));
400 fatal("Cannot create %s\n", tfile);
401 }
402 return (opfil);
403 }
404 return (NULL);
405 }
406
407 /*
408 * Getline gets a line via fgets from the input stream "infile".
409 * The line is put into linbuf and may not be larger than LINSIZ.
410 * If getaline is called with a non-zero value, the current line
411 * is bumped, otherwise it is not(for R.E. searching).
412 */
413
414 static char *
415 getaline(int bumpcur)
416 {
417 char *ret;
418 if (bumpcur)
419 curline++;
420 ret = fgets(linbuf, LINSIZ, infile);
421 return (ret);
422 }
423
424 /*
425 * Line_arg handles line number arguments.
426 * line_arg takes as its argument a pointer to a character string
427 * (assumed to be a line number). If that character string can be
428 * converted to a number(long long), to_line is called with that number,
429 * otherwise error.
430 */
431
432 static void
433 line_arg(char *line)
434 {
435 long long to;
436
437 if (asc_to_ll(line, &to) == ERR)
438 fatal("%s: bad line number\n", line);
439 to_line(to);
440 }
441
442 /*
443 * Num_arg handles repeat arguments.
444 * Num_arg copies the numeric argument to "rep" (error if number is
445 * larger than 20 characters or } is left off). Num_arg then converts
446 * the number and checks for validity. Next num_arg checks the mode
447 * of the previous argument, and applys the argument the correct number
448 * of times. If the mode is not set properly its an error.
449 */
450
451 static void
452 num_arg(char *arg, int md)
453 {
454 offset_t repeat, toline;
455 char rep[21];
456 char *ptr;
457 int len;
458
459 ptr = rep;
460 for (++arg; *arg != '}'; arg += len) {
461 if (*arg == NULL)
462 fatal("%s: missing '}'\n", targ);
463 if ((len = mblen(arg, MB_LEN_MAX)) <= 0)
464 len = 1;
465 if ((ptr + len) >= &rep[20])
466 fatal("%s: Repeat count too large\n", targ);
467 (void) memcpy(ptr, arg, len);
468 ptr += len;
469 }
470 *ptr = NULL;
471 if ((asc_to_ll(rep, &repeat) == ERR) || repeat < 0L)
472 fatal("Illegal repeat count: %s\n", targ);
473 if (md == LINMODE) {
474 toline = offset = curline;
475 for (; repeat > 0LL; repeat--) {
476 toline += offset;
477 to_line(toline);
478 }
479 } else if (md == EXPMODE)
480 for (; repeat > 0LL; repeat--)
481 to_line(findline(expbuf, offset));
482 else
483 fatal("No operation for %s\n", targ);
484 }
485
486 /*
487 * Re_arg handles regular expression arguments.
488 * Re_arg takes a csplit regular expression argument. It checks for
489 * delimiter balance, computes any offset, and compiles the regular
490 * expression. Findline is called with the compiled expression and
491 * offset, and returns the corresponding line number, which is used
492 * as input to the to_line function.
493 */
494
495 static void
496 re_arg(char *string)
497 {
498 char *ptr;
499 char ch;
500 int len;
501
502 ch = *string;
503 ptr = string;
504 ptr++;
505 while (*ptr != ch) {
506 if (*ptr == '\\')
507 ++ptr;
508
509 if (*ptr == NULL)
510 fatal("%s: missing delimiter\n", targ);
511
512 if ((len = mblen(ptr, MB_LEN_MAX)) <= 0)
513 len = 1;
514 ptr += len;
515 }
516
517 /*
518 * The line below was added because compile no longer supports
519 * the fourth argument being passed. The fourth argument used
520 * to be '/' or '%'.
521 */
522
523 *ptr = NULL;
524 if (asc_to_ll(++ptr, &offset) == ERR)
525 fatal("%s: illegal offset\n", string);
526
527 /*
528 * The line below was added because INIT which did this for us
529 * was removed from compile in regexp.h
530 */
531
532 string++;
533 expbuf = compile(string, (char *)0, (char *)0);
534 if (regerrno)
535 PERROR(regerrno);
536 to_line(findline(expbuf, offset));
537 }
538
539 /*
540 * Sig handles breaks. When a break occurs the signal is reset,
541 * and fatal is called to clean up and print the argument which
542 * was being processed at the time the interrupt occured.
543 */
544
545 /* ARGSUSED */
546 static void
547 sig(int s)
548 {
549 (void) signal(SIGINT, sig);
550 fatal("Interrupt - program aborted at arg '%s'\n", targ);
551 }
552
553 /*
554 * To_line creates split files.
555 * To_line gets as its argument the line which the current argument
556 * referenced. To_line calls getfile for a new output stream, which
557 * does nothing if create is False. If to_line's argument is not LAST
558 * it checks that the current line is not greater than its argument.
559 * While the current line is less than the desired line to_line gets
560 * lines and flushes(error if EOF is reached).
561 * If to_line's argument is LAST, it checks for more lines, and gets
562 * and flushes lines till the end of file.
563 * Finally, to_line calls closefile to close the output stream.
564 */
565
566 static void
567 to_line(offset_t ln)
568 {
569 outfile = getfile();
570 if (ln != LAST) {
571 if (curline > ln)
572 fatal("%s - out of range\n", targ);
573 while (curline < ln) {
574 if (getaline(TRUE) == NULL)
575 fatal("%s - out of range\n", targ);
576 flush();
577 }
578 } else /* last file */
579 if (getaline(TRUE) != NULL) {
580 flush();
581 for (;;) {
582 if (getaline(TRUE) == NULL)
583 break;
584 flush();
585 }
586 } else
587 fatal("%s - out of range\n", targ);
588 closefile();
589 }
590
591 static void
592 usage()
593 {
594 (void) fprintf(stderr, gettext(
595 "usage: csplit [-ks] [-f prefix] [-n number] "
596 "file arg1 ...argn\n"));
597 exit(1);
598 }