xref: /haiku/src/bin/chop.c (revision 268f99dd7dc4bd7474a8bd2742d3f1ec1de6752a)

// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
//
//  Copyright (c) 2001-2003, Haiku
//
//  This software is part of the Haiku distribution and is covered
//  by the MIT License.
//
//
//  File:        chop.c
//  Author:      Daniel Reinhold (danielre@users.sf.net)
//  Description: splits one file into a collection of smaller files
//
//  Notes:
//  This program was written such that it would have identical output as from
//  the original chop program included with BeOS R5. However, there are a few
//  minor differences:
//
//  a) using "chop -n" (with no other args) crashes the original version,
//     but not this one.
//
//  b) filenames are enclosed in single quotes here, but are not in the original.
//     It is generally better to enquote filenames for error messages so that
//     problems with the name (e.g extra space chars) can be more easily detected.
//
//  c) this version checks for validity of the input file (including file size)
//     before there is any attempt to open it -- this changes the error output
//     slightly from the original in some situations. It can also prevent some
//     weirdness. For example, the original version will take a command such as:
//
//         chop /dev/ports/serial1
//
//     and attempt to open the device. If serial1 is unused, this will actually
//     block while waiting for data from the serial port. This version will never
//     encounter that because the device will be found to have size 0 which will
//     abort immediately. Since the semantics of chop don't make sense for such
//     devices as the source, this is really the better behavior (provided that
//     anyone ever attempts to use such strange arguments, which is unlikely).
//
// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~

#include <OS.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>


void chop_file (int, char *, off_t);
void do_chop   (char *);
void usage     (void);


// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// globals

#define BLOCKSIZE 64 * 1024        // file data is read in BLOCKSIZE blocks
static char Block[BLOCKSIZE];      // and stored in the global Block array

static int KBytesPerChunk = 1400;  // determines size of output files


void
usage()
{
	printf("Usage: chop [-n kbyte_per_chunk] file\n");
	printf("Splits file into smaller files named file00, file01...\n");
	printf("Default split size is 1400k\n");
}



int
main(int argc, char *argv[])
{
	char *arg = NULL;
	char *first;

	if ((argc < 2) || (argc > 4)) {
		usage();
		return 0;
	}

	first = *++argv;

	if (strcmp(first, "--help") == 0) {
		usage();
		return 0;
	}

	if (strcmp(first, "-n") == 0) {
		if (--argc > 1) {
			char *num = *++argv;

			if (!isdigit(*num))
				printf("-n option needs a numeric argument\n");
			else {
				int b = atoi(num);
				KBytesPerChunk = (b < 1 ? 1 : b);

				if (--argc > 1)
					arg = *++argv;
				else
					printf("no file specified\n");
			}
		}
		else
			printf("-n option needs a numeric argument\n");
	}
	else
		arg = first;

	if (arg)
		do_chop(arg);

	putchar ('\n');
	return 0;
}


void
do_chop(char *fname)
{
	// do some checks for validity
	// then call chop_file() to do the actual read/writes

	struct stat e;
	off_t  fsize;
	int    fd;

	// input file must exist
	if (stat(fname, &e) == -1) {
		fprintf(stderr, "'%s': no such file or directory\n", fname);
		return;
	}

	// and it must be not be a directory
	if (S_ISDIR(e.st_mode)) {
		fprintf(stderr, "'%s' is a directory\n", fname);
		return;
	}

	// needs to be big enough such that splitting it actually does something
	fsize = e.st_size;
	if (fsize < (KBytesPerChunk * 1024)) {
		fprintf(stderr, "'%s': file is already small enough\n", fname);
		return;
	}

	// also, don't chop up if chunk files are already present
	{
		char buf[256];

		strcpy(buf, fname);
		strcat(buf, "00");

		if (stat(buf, &e) >= 0) {
			fprintf(stderr, "'%s' already exists - aborting\n", buf);
			return;
		}
	}

	// finally! chop up the file
	fd = open(fname, O_RDONLY);
	if (fd < 0)
		fprintf(stderr, "can't open '%s': %s\n", fname, strerror(errno));
	else {
		chop_file(fd, fname, fsize);
		close(fd);
	}
}


void
chop_file(int fdin, char *fname, off_t fsize)
{
	const off_t chunk_size = KBytesPerChunk * 1024;  // max bytes written to any output file

	bool open_next_file = true;  // when to open a new output file
	char fnameN[256];            // name of the current output file (file01, file02, etc.)
	int  index = 0;              // used to generate the next output file name
	int  fdout = -1;             // output file descriptor

	ssize_t got;                 // size of the current data block -- i.e. from the last read()
	ssize_t put;                 // number of bytes just written   -- i.e. from the last write()
	ssize_t needed;              // how many bytes we can safely write to the current output file
	ssize_t avail;               // how many bytes we can safely grab from the current data block
	off_t   curr_written = 0;    // number of bytes written to the current output file
	off_t   total_written = 0;   // total bytes written out to all output files

	char *beg = Block;  // pointer to the beginning of the block data to be written out
	char *end = Block;  // end of the current block (init to beginning to force first block read)

	printf("Chopping up %s into %d kbyte chunks\n", fname, KBytesPerChunk);

	while (total_written < fsize) {
		if (beg >= end) {
			// read in another block
			got = read(fdin, Block, BLOCKSIZE);
			if (got <= 0)
				break;

			beg = Block;
			end = Block + got - 1;
		}

		if (open_next_file) {
			// start a new output file
			sprintf(fnameN,  "%s%02d", fname, index++);

			fdout = open(fnameN, O_WRONLY|O_CREAT);
			if (fdout < 0) {
				fprintf(stderr, "unable to create chunk file '%s': %s\n", fnameN, strerror(errno));
				return;
			}
			curr_written = 0;
			open_next_file = false;
		}

		needed = chunk_size - curr_written;
		avail  = end - beg + 1;
		if (needed > avail)
			needed = avail;

		if (needed > 0) {
			put = write(fdout, beg, needed);
			beg += put;

			curr_written  += put;
			total_written += put;
		}

		if (curr_written >= chunk_size) {
			// the current output file is full
			close(fdout);
			open_next_file = true;
		}
	}

	// close up the last output file if it's still open
	if (!open_next_file)
		close(fdout);
}