pcopy-gen.tar

pcopy-opts.c0000644000175000017500000005727511751317322012020 0ustar  bkorbdev#ifndef __doxygen__
#define OPTION_CODE_COMPILE 1
#include "pcopy-opts.h"
#include <sys/types.h>
#include <sys/stat.h>

#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#ifdef  __cplusplus
extern "C" {
#endif
extern FILE * option_usage_fp;

/* TRANSLATORS: choose the translation for option names wisely because you
                cannot ever change your mind. */
#define zCopyright      (pcopy_opt_strs+0)
#define zLicenseDescrip (pcopy_opt_strs+251)

extern tUsageProc pcopy_usage;
/*
 *  global included definitions
 */
pthread_t *     pth_list           = NULL;
pthread_mutex_t tty_mutex          = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t  th_start_cond      = PTHREAD_COND_INITIALIZER;
pthread_mutex_t th_start_mutex     = PTHREAD_MUTEX_INITIALIZER;

bool            curses_active      = false;
uint64_t        nsec_per_iteration = 0;
unsigned long   iteration_chunk    = 0;

#ifndef NULL
#  define NULL 0
#endif

/*
 *  pcopy option static const strings
 */
static char const pcopy_opt_strs[1851] =
/*     0 */ "pcopy 0.4\n"
            "Copyright (C) 2012 Bruce Korb, all rights reserved.\n"
            "This is free software. It is licensed for use, modification and\n"
            "redistribution under the terms of the\n"
            "GNU General Public License, version 3 or later\n"
            "    <http://gnu.org/licenses/gpl.html>\n\0"
/*   251 */ "pcopy is free software: you can redistribute it and/or modify it under the\n"
            "terms of the GNU General Public License as published by the Free Software\n"
            "Foundation, either version 3 of the License, or (at your option) any later\n"
            "version.\n\n"
            "pcopy is distributed in the hope that it will be useful, but WITHOUT ANY\n"
            "WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS\n"
            "FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more\n"
            "details.\n\n"
            "You should have received a copy of the GNU General Public License along\n"
            "with this program.  If not, see <http://www.gnu.org/licenses/>.\n\0"
/*   850 */ "How many / how long / how much specifications:\0"
/*   897 */ "limit copy threads to count\0"
/*   925 */ "THREAD_CT\0"
/*   935 */ "thread-ct\0"
/*   945 */ "maximum bytes per second flow\0"
/*   975 */ "FLOW_RATE\0"
/*   985 */ "flow-rate\0"
/*   995 */ "maximum bytes per read chunk\0"
/*  1024 */ "MAX_CHUNK\0"
/*  1034 */ "max-chunk\0"
/*  1044 */ "Where to put the output:\0"
/*  1069 */ "Copy files to the dest destination\0"
/*  1104 */ "DESTINATION\0"
/*  1116 */ "destination\0"
/*  1128 */ "User information:\0"
/*  1146 */ "omit progress output\0"
/*  1167 */ "QUIET\0"
/*  1173 */ "quiet\0"
/*  1179 */ "Display extended usage information and exit\0"
/*  1223 */ "help\0"
/*  1228 */ "Extended usage information passed thru pager\0"
/*  1273 */ "more-help\0"
/*  1283 */ "Output version information and exit\0"
/*  1319 */ "version\0"
/*  1327 */ "Abbreviated usage to stdout\0"
/*  1355 */ "usage\0"
/*  1361 */ "Save the option state to a config file\0"
/*  1400 */ "save-opts\0"
/*  1410 */ "Load options from a config file\0"
/*  1442 */ "LOAD_OPTS\0"
/*  1452 */ "no-load-opts\0"
/*  1465 */ "no\0"
/*  1468 */ "PCOPY\0"
/*  1474 */ "pcopy - Parallel copy - Ver. 0.4\n"
            "USAGE:  %s [ -<flag> [<val>] | --<name>[{=| }<val>] ]... [ <file> ... ]\n\0"
/*  1580 */ "$HOME\0"
/*  1586 */ ".\0"
/*  1588 */ ".pcopyrc\0"
/*  1597 */ "autogen-users@lists.sourceforge.net\0"
/*  1633 */ "\n"
            "If no arguments are provided, input arguments are read from stdin,\n"
            "one per line; blank and '#'-prefixed lines are comments.\n"
            "'stdin' may not be a terminal (tty).\n\0"
/*  1796 */ "\n"
            "Copy a file in several chunks in parallel.\n\0"
/*  1841 */ "pcopy 0.4";

/*
 *  limits option description:
 */
#define LIMITS_DESC      (pcopy_opt_strs+850)
#define LIMITS_FLAGS     (OPTST_DOCUMENT | OPTST_NO_INIT)

/*
 *  thread-ct option description:
 */
#define THREAD_CT_DESC      (pcopy_opt_strs+897)
#define THREAD_CT_NAME      (pcopy_opt_strs+925)
#define THREAD_CT_name      (pcopy_opt_strs+935)
#define THREAD_CT_DFT_ARG   ((char const*)8)
#define THREAD_CT_FLAGS     (OPTST_DISABLED \
        | OPTST_SET_ARGTYPE(OPARG_TYPE_NUMERIC))

/*
 *  flow-rate option description:
 */
#define FLOW_RATE_DESC      (pcopy_opt_strs+945)
#define FLOW_RATE_NAME      (pcopy_opt_strs+975)
#define FLOW_RATE_name      (pcopy_opt_strs+985)
#define FLOW_RATE_FLAGS     (OPTST_DISABLED \
        | OPTST_SET_ARGTYPE(OPARG_TYPE_NUMERIC) \
        | OPTST_SCALED_NUM)

/*
 *  max-chunk option description:
 */
#define MAX_CHUNK_DESC      (pcopy_opt_strs+995)
#define MAX_CHUNK_NAME      (pcopy_opt_strs+1024)
#define MAX_CHUNK_name      (pcopy_opt_strs+1034)
#define MAX_CHUNK_DFT_ARG   ((char const*)16384)
#define MAX_CHUNK_FLAGS     (OPTST_DISABLED \
        | OPTST_SET_ARGTYPE(OPARG_TYPE_NUMERIC) \
        | OPTST_SCALED_NUM)

/*
 *  where option description:
 */
#define WHERE_DESC      (pcopy_opt_strs+1044)
#define WHERE_FLAGS     (OPTST_DOCUMENT | OPTST_NO_INIT)

/*
 *  destination option description:
 */
#define DESTINATION_DESC      (pcopy_opt_strs+1069)
#define DESTINATION_NAME      (pcopy_opt_strs+1104)
#define DESTINATION_name      (pcopy_opt_strs+1116)
#define DESTINATION_FLAGS     (OPTST_DISABLED \
        | OPTST_SET_ARGTYPE(OPARG_TYPE_STRING))

/*
 *  information option description:
 */
#define INFORMATION_DESC      (pcopy_opt_strs+1128)
#define INFORMATION_FLAGS     (OPTST_DOCUMENT | OPTST_NO_INIT)

/*
 *  quiet option description:
 */
#define QUIET_DESC      (pcopy_opt_strs+1146)
#define QUIET_NAME      (pcopy_opt_strs+1167)
#define QUIET_name      (pcopy_opt_strs+1173)
#define QUIET_FLAGS     (OPTST_DISABLED)

/*
 *  Help/More_Help/Version option descriptions:
 */
#define HELP_DESC       (pcopy_opt_strs+1179)
#define HELP_name       (pcopy_opt_strs+1223)
#ifdef HAVE_WORKING_FORK
#define MORE_HELP_DESC  (pcopy_opt_strs+1228)
#define MORE_HELP_name  (pcopy_opt_strs+1273)
#define MORE_HELP_FLAGS (OPTST_IMM | OPTST_NO_INIT)
#else
#define MORE_HELP_DESC  NULL
#define MORE_HELP_name  NULL
#define MORE_HELP_FLAGS (OPTST_OMITTED | OPTST_NO_INIT)
#endif
#ifdef NO_OPTIONAL_OPT_ARGS
#  define VER_FLAGS     (OPTST_IMM | OPTST_NO_INIT)
#else
#  define VER_FLAGS     (OPTST_SET_ARGTYPE(OPARG_TYPE_STRING) | \
                         OPTST_ARG_OPTIONAL | OPTST_IMM | OPTST_NO_INIT)
#endif
#define VER_DESC        (pcopy_opt_strs+1283)
#define VER_name        (pcopy_opt_strs+1319)
#define USAGE_DESC      (pcopy_opt_strs+1327)
#define USAGE_name      (pcopy_opt_strs+1355)
#define SAVE_OPTS_DESC  (pcopy_opt_strs+1361)
#define SAVE_OPTS_name  (pcopy_opt_strs+1400)
#define LOAD_OPTS_DESC     (pcopy_opt_strs+1410)
#define LOAD_OPTS_NAME     (pcopy_opt_strs+1442)
#define NO_LOAD_OPTS_name  (pcopy_opt_strs+1452)
#define LOAD_OPTS_pfx      (pcopy_opt_strs+1465)
#define LOAD_OPTS_name     (NO_LOAD_OPTS_name + 3)
/*
 *  Declare option callback procedures
 */
extern tOptProc
    optionBooleanVal,   optionNestedVal,    optionNumericVal,
    optionPagedUsage,   optionPrintVersion, optionResetOpt,
    optionStackArg,     optionTimeDate,     optionTimeVal,
    optionUnstackArg,   optionVendorOption;
static tOptProc
    doUsageOpt;
#define VER_PROC        optionPrintVersion

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/**
 *  Define the pcopy Option Descriptions.
 * This is an array of OPTION_CT entries, one for each
 * option that the pcopy program responds to.
 */
static tOptDesc optDesc[OPTION_CT] = {
  {  /* entry idx, value */ 0, 0,
     /* equiv idx, value */ 0, 0,
     /* equivalenced to  */ NO_EQUIVALENT,
     /* min, max, act ct */ 0, 0, 0,
     /* opt state flags  */ LIMITS_FLAGS, 0,
     /* last opt argumnt */ { NULL },
     /* arg list/cookie  */ NULL,
     /* must/cannot opts */ NULL, NULL,
     /* option proc      */ NULL,
     /* desc, NAME, name */ LIMITS_DESC, NULL, NULL,
     /* disablement strs */ NULL, NULL },

  {  /* entry idx, value */ 1, VALUE_OPT_THREAD_CT,
     /* equiv idx, value */ 1, VALUE_OPT_THREAD_CT,
     /* equivalenced to  */ NO_EQUIVALENT,
     /* min, max, act ct */ 0, 1, 0,
     /* opt state flags  */ THREAD_CT_FLAGS, 0,
     /* last opt argumnt */ { THREAD_CT_DFT_ARG },
     /* arg list/cookie  */ NULL,
     /* must/cannot opts */ NULL, NULL,
     /* option proc      */ optionNumericVal,
     /* desc, NAME, name */ THREAD_CT_DESC, THREAD_CT_NAME, THREAD_CT_name,
     /* disablement strs */ NULL, NULL },

  {  /* entry idx, value */ 2, VALUE_OPT_FLOW_RATE,
     /* equiv idx, value */ 2, VALUE_OPT_FLOW_RATE,
     /* equivalenced to  */ NO_EQUIVALENT,
     /* min, max, act ct */ 0, 1, 0,
     /* opt state flags  */ FLOW_RATE_FLAGS, 0,
     /* last opt argumnt */ { NULL }, /* --flow-rate */
     /* arg list/cookie  */ NULL,
     /* must/cannot opts */ NULL, NULL,
     /* option proc      */ optionNumericVal,
     /* desc, NAME, name */ FLOW_RATE_DESC, FLOW_RATE_NAME, FLOW_RATE_name,
     /* disablement strs */ NULL, NULL },

  {  /* entry idx, value */ 3, VALUE_OPT_MAX_CHUNK,
     /* equiv idx, value */ 3, VALUE_OPT_MAX_CHUNK,
     /* equivalenced to  */ NO_EQUIVALENT,
     /* min, max, act ct */ 0, 1, 0,
     /* opt state flags  */ MAX_CHUNK_FLAGS, 0,
     /* last opt argumnt */ { MAX_CHUNK_DFT_ARG },
     /* arg list/cookie  */ NULL,
     /* must/cannot opts */ NULL, NULL,
     /* option proc      */ optionNumericVal,
     /* desc, NAME, name */ MAX_CHUNK_DESC, MAX_CHUNK_NAME, MAX_CHUNK_name,
     /* disablement strs */ NULL, NULL },

  {  /* entry idx, value */ 0, 0,
     /* equiv idx, value */ 0, 0,
     /* equivalenced to  */ NO_EQUIVALENT,
     /* min, max, act ct */ 0, 0, 0,
     /* opt state flags  */ WHERE_FLAGS, 0,
     /* last opt argumnt */ { NULL },
     /* arg list/cookie  */ NULL,
     /* must/cannot opts */ NULL, NULL,
     /* option proc      */ NULL,
     /* desc, NAME, name */ WHERE_DESC, NULL, NULL,
     /* disablement strs */ NULL, NULL },

  {  /* entry idx, value */ 5, VALUE_OPT_DESTINATION,
     /* equiv idx, value */ 5, VALUE_OPT_DESTINATION,
     /* equivalenced to  */ NO_EQUIVALENT,
     /* min, max, act ct */ 0, 1, 0,
     /* opt state flags  */ DESTINATION_FLAGS, 0,
     /* last opt argumnt */ { NULL }, /* --destination */
     /* arg list/cookie  */ NULL,
     /* must/cannot opts */ NULL, NULL,
     /* option proc      */ NULL,
     /* desc, NAME, name */ DESTINATION_DESC, DESTINATION_NAME, DESTINATION_name,
     /* disablement strs */ NULL, NULL },

  {  /* entry idx, value */ 0, 0,
     /* equiv idx, value */ 0, 0,
     /* equivalenced to  */ NO_EQUIVALENT,
     /* min, max, act ct */ 0, 0, 0,
     /* opt state flags  */ INFORMATION_FLAGS, 0,
     /* last opt argumnt */ { NULL },
     /* arg list/cookie  */ NULL,
     /* must/cannot opts */ NULL, NULL,
     /* option proc      */ NULL,
     /* desc, NAME, name */ INFORMATION_DESC, NULL, NULL,
     /* disablement strs */ NULL, NULL },

  {  /* entry idx, value */ 7, VALUE_OPT_QUIET,
     /* equiv idx, value */ 7, VALUE_OPT_QUIET,
     /* equivalenced to  */ NO_EQUIVALENT,
     /* min, max, act ct */ 0, 1, 0,
     /* opt state flags  */ QUIET_FLAGS, 0,
     /* last opt argumnt */ { NULL }, /* --quiet */
     /* arg list/cookie  */ NULL,
     /* must/cannot opts */ NULL, NULL,
     /* option proc      */ NULL,
     /* desc, NAME, name */ QUIET_DESC, QUIET_NAME, QUIET_name,
     /* disablement strs */ NULL, NULL },

  {  /* entry idx, value */ INDEX_OPT_VERSION, VALUE_OPT_VERSION,
     /* equiv idx value  */ NO_EQUIVALENT, VALUE_OPT_VERSION,
     /* equivalenced to  */ NO_EQUIVALENT,
     /* min, max, act ct */ 0, 1, 0,
     /* opt state flags  */ VER_FLAGS, 0,
     /* last opt argumnt */ { NULL },
     /* arg list/cookie  */ NULL,
     /* must/cannot opts */ NULL, NULL,
     /* option proc      */ VER_PROC,
     /* desc, NAME, name */ VER_DESC, NULL, VER_name,
     /* disablement strs */ NULL, NULL },



  {  /* entry idx, value */ INDEX_OPT_HELP, VALUE_OPT_HELP,
     /* equiv idx value  */ NO_EQUIVALENT, VALUE_OPT_HELP,
     /* equivalenced to  */ NO_EQUIVALENT,
     /* min, max, act ct */ 0, 1, 0,
     /* opt state flags  */ OPTST_IMM | OPTST_NO_INIT, 0,
     /* last opt argumnt */ { NULL },
     /* arg list/cookie  */ NULL,
     /* must/cannot opts */ NULL, NULL,
     /* option proc      */ doUsageOpt,
     /* desc, NAME, name */ HELP_DESC, NULL, HELP_name,
     /* disablement strs */ NULL, NULL },

  {  /* entry idx, value */ INDEX_OPT_MORE_HELP, VALUE_OPT_MORE_HELP,
     /* equiv idx value  */ NO_EQUIVALENT, VALUE_OPT_MORE_HELP,
     /* equivalenced to  */ NO_EQUIVALENT,
     /* min, max, act ct */ 0, 1, 0,
     /* opt state flags  */ MORE_HELP_FLAGS, 0,
     /* last opt argumnt */ { NULL },
     /* arg list/cookie  */ NULL,
     /* must/cannot opts */ NULL,  NULL,
     /* option proc      */ optionPagedUsage,
     /* desc, NAME, name */ MORE_HELP_DESC, NULL, MORE_HELP_name,
     /* disablement strs */ NULL, NULL },

  {  /* entry idx, value */ INDEX_OPT_USAGE, VALUE_OPT_USAGE,
     /* equiv idx value  */ NO_EQUIVALENT, VALUE_OPT_USAGE,
     /* equivalenced to  */ NO_EQUIVALENT,
     /* min, max, act ct */ 0, 1, 0,
     /* opt state flags  */ OPTST_IMM | OPTST_NO_INIT, 0,
     /* last opt argumnt */ { NULL },
     /* arg list/cookie  */ NULL,
     /* must/cannot opts */ NULL,  NULL,
     /* option proc      */ doUsageOpt,
     /* desc, NAME, name */ USAGE_DESC, NULL, USAGE_name,
     /* disablement strs */ NULL, NULL },

  {  /* entry idx, value */ INDEX_OPT_SAVE_OPTS, VALUE_OPT_SAVE_OPTS,
     /* equiv idx value  */ NO_EQUIVALENT, VALUE_OPT_SAVE_OPTS,
     /* equivalenced to  */ NO_EQUIVALENT,
     /* min, max, act ct */ 0, 1, 0,
     /* opt state flags  */ OPTST_SET_ARGTYPE(OPARG_TYPE_STRING)
                          | OPTST_ARG_OPTIONAL | OPTST_NO_INIT, 0,
     /* last opt argumnt */ { NULL },
     /* arg list/cookie  */ NULL,
     /* must/cannot opts */ NULL,  NULL,
     /* option proc      */ NULL,
     /* desc, NAME, name */ SAVE_OPTS_DESC, NULL, SAVE_OPTS_name,
     /* disablement strs */ NULL, NULL },

  {  /* entry idx, value */ INDEX_OPT_LOAD_OPTS, VALUE_OPT_LOAD_OPTS,
     /* equiv idx value  */ NO_EQUIVALENT, VALUE_OPT_LOAD_OPTS,
     /* equivalenced to  */ NO_EQUIVALENT,
     /* min, max, act ct */ 0, NOLIMIT, 0,
     /* opt state flags  */ OPTST_SET_ARGTYPE(OPARG_TYPE_STRING)
			  | OPTST_DISABLE_IMM, 0,
     /* last opt argumnt */ { NULL },
     /* arg list/cookie  */ NULL,
     /* must/cannot opts */ NULL, NULL,
     /* option proc      */ optionLoadOpt,
     /* desc, NAME, name */ LOAD_OPTS_DESC, LOAD_OPTS_NAME, LOAD_OPTS_name,
     /* disablement strs */ NO_LOAD_OPTS_name, LOAD_OPTS_pfx }
};


/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 *
 *  Define the pcopy Option Environment
 */
#define zPROGNAME       (pcopy_opt_strs+1468)
#define zUsageTitle     (pcopy_opt_strs+1474)
#define zRcName         (pcopy_opt_strs+1588)
static char const * const apzHomeList[3] = {
    pcopy_opt_strs+1580,
    pcopy_opt_strs+1586,
    NULL };
#define zBugsAddr       (pcopy_opt_strs+1597)
#define zExplain        (pcopy_opt_strs+1633)
#define zDetail         (pcopy_opt_strs+1796)
#define zFullVersion    (pcopy_opt_strs+1841)
/* extracted from optcode.tlib near line 350 */

#define OPTPROC_BASE OPTPROC_NONE
#define translate_option_strings NULL


#define pcopy_full_usage (NULL)

#define pcopy_short_usage (NULL)

#endif /* not defined __doxygen__ */

/*
 *  Create the static procedure(s) declared above.
 */
/**
 * The callout function that invokes the pcopy_usage function.
 *
 * @param pOptions the AutoOpts option description structure
 * @param pOptDesc the descriptor for the "help" (usage) option.
 * @noreturn
 */
static void
doUsageOpt(tOptions * pOptions, tOptDesc * pOptDesc)
{
    int ex_code = (pOptDesc->optIndex == INDEX_OPT_HELP)
        ? PCOPY_EXIT_SUCCESS : AO_EXIT_REQ_USAGE;
    pcopy_usage(&pcopyOptions, ex_code);
    /* NOTREACHED */
    (void)pOptions;
}
/* extracted from optmain.tlib near line 120 */

/**
 * strip (destructively) the leading and trailing white space.
 * Trailing white space is trimmed with a NUL byte.
 * The returned address is that of the first character after the
 * leading white space.  Characters are not moved.
 *
 * @param pz_s source text pointer
 * @returns pointer to the same text buffer, but after finding the
 * first non-white space character.
 */
static char *
trim_input_line(char * pz_s)
{
    char* pz_e = pz_s + strlen(pz_s);
    while ((pz_e > pz_s) && isspace((unsigned int)pz_e[-1]))  pz_e--;
    *pz_e = '\0';
    while ((unsigned int)isspace(*pz_s))  pz_s++;

    switch (*pz_s) {
    case '\0':
    case '#':
        return NULL;
    default:
        return pz_s;
    }
}

extern int pcopy(char const* pz_fname);
/* extracted from optmain.tlib near line 193 */

/**
 * validate file name and dispach callout procedure.
 * This procedure is generated by AutoOpts.
 * It will make sure that the input file name refers to a file
 * that exists.
 *
 * @param pz_fname the name of the file to process
 * @returns program exit code flag
 */
static pcopy_exit_code_t
validate_fname(char const* pz_fname)
{
    static char const * pz_fs_err = NULL;

    if (pz_fs_err == NULL)
        pz_fs_err = _("fs error %d (%s) %s-ing %s\n");

    {
        struct stat sb;
        if (stat(pz_fname, &sb) < 0) {
            fprintf(stderr, pz_fs_err, errno, strerror(errno), "stat",
                    pz_fname);
            return PCOPY_EXIT_FAILURE;
        }
    }
/* extracted from optmain.tlib near line 278 */


    return pcopy(pz_fname);
}
/* extracted from optmain.tlib near line 357 */

/**
 * Generated main procedure.  This will call the validate_fname procedure
 * for every operand on the command line.  If there are no operands, then stdin
 * is read for a list of file names to process.  stdin must not be a terminal.
 * It must be a pipe or a file.
 *
 * @param argc argument count
 * @param argv argument vector
 * @returns program exit code
 */
int
main(int argc, char** argv)
{
    int res = 0;
    {
        int ct = optionProcess(&pcopyOptions, argc, argv);
        argc -= ct;
        argv += ct;
    }
    
/* extracted from pcopy-opts.def near line 31 */

    if (! HAVE_OPT(QUIET)) {
        initscr();
        curses_active = true;
    }
    pth_list = malloc(OPT_VALUE_THREAD_CT * sizeof(*pth_list));
    if (pth_list == NULL)
        fserr(PCOPY_EXIT_NO_MEM, "allocate", "pthread list");
/* extracted from optmain.tlib near line 382 */

    /*
     *  Input list from command line
     */
    if (argc > 0) {
        do  {
            res |= validate_fname(*(argv++));
        } while (--argc > 0);
    }

    /*
     *  Input list from tty input
     */
    else if (isatty(STDIN_FILENO)) {
        fputs(_("pcopy ERROR: input list is a tty\n"), stderr);
        USAGE(PCOPY_EXIT_FAILURE);
        /* NOTREACHED */
    }

    /*
     *  Input list from a pipe or file or some such
     */
    else {
        int in_ct   = 0;
        size_t pg_size = getpagesize();
        char* buf   = malloc(pg_size);
        if (buf == NULL) {
            fputs(_("pcopy ERROR: no memory for input list\n"), stderr);
            return PCOPY_EXIT_FAILURE;
        }

        for (;;) {
            char* pz = fgets(buf, (ssize_t)pg_size, stdin);
            if (pz == NULL)
                break;

            pz = trim_input_line(pz);
            if (pz != NULL) {
                 res |= validate_fname(pz);
                 in_ct++;
            }
        }

        if (in_ct == 0)
            fputs(_("pcopy Warning:  no input lines were read\n"), stderr);
        free(buf);
    }
    
/* extracted from pcopy-opts.def near line 39 */

    if (curses_active) endwin();
    return res;
}
/* extracted from optmain.tlib near line 1113 */

/**
 * Print a usage message with a format and va_list argument.
 * The pcopy_usage function is then invoked to print
 * the error usage text (somewhat abbreviated) and then exit.
 *
 * @param[in] fmt the message format string
 * @param[in] ap  the var-arg list.
 * @noreturn
 */
void
vusage_message(char const * fmt, va_list ap)
{
    char const * er_leader = _("pcopy usage error:\n");
    fputs(er_leader, stderr);
    vfprintf(stderr, fmt, ap);
    pcopy_usage(&pcopyOptions, PCOPY_EXIT_FAILURE);
    /* NOTREACHED */
}

/**
 * Print a usage message with a format and a variable argument list. 
 * vusage_message() is called to do the work.
 *
 * @param[in] fmt the message format string
 * @param[in] ... the argument list for the message
 * @noreturn
 */
void
usage_message(char const * fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    vusage_message(fmt, ap);
    /* NOTREACHED */
    va_end(ap);
}

/**
 * Print a fatal error message and die
 *
 * @param[in] exit_code  the value to call exit(3) with
 * @param[in] fmt        the death rattle message
 * @param[in] ap         the argument list for the message
 * @noreturn
 */
void
vdie(int exit_code, char const * fmt, va_list ap)
{
    char const * die_leader = _("pcopy fatal error:\n");

    if (curses_active) endwin();

    fputs(die_leader, stderr);
    vfprintf(stderr, fmt, ap);
    fflush(stderr);
    exit(exit_code);
    /* NOTREACHED */
}

/**
 * Print a fatal error message and die
 *
 * @param[in] exit_code  the value to call exit(3) with
 * @param[in] fmt        the death rattle message
 * @param[in] ...        the list of arguments for the message
 * @noreturn
 */
void
die(int exit_code, char const * fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    vdie(exit_code, fmt, ap);
    /* NOTREACHED */
    va_end(ap);
}

/**
 * Print a file system error fatal error message and die
 *
 * @param[in] exit_code  the value to call exit(3) with.
 * @param[in] op         the operation that failed.
 * @param[in] fname      the file name the operation was on.
 * @noreturn
 */
void
fserr(int exit_code, char const * op, char const * fname)
{
    static char const * fserr_fmt =
        _("fserr %d (%s) performing '%s' on %s\n");
    die(exit_code, fserr_fmt, errno, strerror(errno), op, fname);
    /* NOTREACHED */
}

/**
 * The directory containing the data associated with pcopy.
 */
#ifndef  PKGDATADIR
# define PKGDATADIR ""
#endif

/**
 * Information about the person or institution that packaged pcopy
 * for the current distribution.
 */
#ifndef  WITH_PACKAGER
# define pcopy_packager_info NULL
#else
static char const pcopy_packager_info[] =
    "Packaged by " WITH_PACKAGER

# ifdef WITH_PACKAGER_VERSION
        " ("WITH_PACKAGER_VERSION")"
# endif

# ifdef WITH_PACKAGER_BUG_REPORTS
    "\nReport pcopy bugs to " WITH_PACKAGER_BUG_REPORTS
# endif
    "\n";
#endif
#ifndef __doxygen__

#endif /* __doxygen__ */
/**
 * The option definitions for pcopy.  The one structure that
 * binds them all.
 */
tOptions pcopyOptions = {
    OPTIONS_STRUCT_VERSION,
    0, NULL,                    /* original argc + argv    */
    ( OPTPROC_BASE
    + OPTPROC_ERRSTOP
    + OPTPROC_SHORTOPT
    + OPTPROC_LONGOPT
    + OPTPROC_NO_REQ_OPT
    + OPTPROC_ENVIRON ),
    0, NULL,                    /* current option index, current option */
    NULL,         NULL,         zPROGNAME,
    zRcName,      zCopyright,   zLicenseDescrip,
    zFullVersion, apzHomeList,  zUsageTitle,
    zExplain,     zDetail,      optDesc,
    zBugsAddr,                  /* address to send bugs to */
    NULL, NULL,                 /* extensions/saved state  */
    pcopy_usage, /* usage procedure */
    translate_option_strings,   /* translation procedure */
    /*
     *  Indexes to special options
     */
    { INDEX_OPT_MORE_HELP, /* more-help option index */
      INDEX_OPT_SAVE_OPTS, /* save option index */
      NO_EQUIVALENT, /* '-#' option index */
      NO_EQUIVALENT /* index of default opt */
    },
    14 /* full option count */, 8 /* user option count */,
    pcopy_full_usage, pcopy_short_usage,
    NULL, NULL,
    PKGDATADIR, pcopy_packager_info
};

#ifdef  __cplusplus
}
#endif
/* pcopy-opts.c ends here */
pcopy-opts.h0000644000175000017500000001361111751317322012007 0ustar  bkorbdev#ifndef AUTOOPTS_PCOPY_OPTS_H_GUARD
#define AUTOOPTS_PCOPY_OPTS_H_GUARD 1
#include "pcopy-cfg.h"
#include <autoopts/options.h>
#include <stdarg.h>

/*
 *  Ensure that the library used for compiling this generated header is at
 *  least as new as the version current when the header template was released
 *  (not counting patch version increments).  Also ensure that the oldest
 *  tolerable version is at least as old as what was current when the header
 *  template was released.
 */

/*
 *  Enumeration of each option:
 */
typedef enum {
    INDEX_OPT_THREAD_CT    =  1,
    INDEX_OPT_FLOW_RATE    =  2,
    INDEX_OPT_MAX_CHUNK    =  3,
    INDEX_OPT_DESTINATION  =  5,
    INDEX_OPT_QUIET        =  7,
    INDEX_OPT_VERSION      =  8,
    INDEX_OPT_HELP         =  9,
    INDEX_OPT_MORE_HELP    = 10,
    INDEX_OPT_USAGE        = 11,
    INDEX_OPT_SAVE_OPTS    = 12,
    INDEX_OPT_LOAD_OPTS    = 13
} teOptIndex;

#define OPTION_CT    14
#define PCOPY_VERSION       "0.4"
#define PCOPY_FULL_VERSION  "pcopy 0.4"

/*
 *  Interface defines for all options.  Replace "n" with the UPPER_CASED
 *  option name (as in the teOptIndex enumeration above).
 *  e.g. HAVE_OPT(LIMITS)
 */
#define         DESC(n) (pcopyOptions.pOptDesc[INDEX_OPT_## n])
#define     HAVE_OPT(n) (! UNUSED_OPT(& DESC(n)))
#define      OPT_ARG(n) (DESC(n).optArg.argString)
#define    STATE_OPT(n) (DESC(n).fOptState & OPTST_SET_MASK)
#define    COUNT_OPT(n) (DESC(n).optOccCt)
#define    ISSEL_OPT(n) (SELECTED_OPT(&DESC(n)))
#define ISUNUSED_OPT(n) (UNUSED_OPT(& DESC(n)))
#define  ENABLED_OPT(n) (! DISABLED_OPT(& DESC(n)))
#define  STACKCT_OPT(n) (((tArgList*)(DESC(n).optCookie))->useCt)
#define STACKLST_OPT(n) (((tArgList*)(DESC(n).optCookie))->apzArgs)
#define    CLEAR_OPT(n) STMTS( \
                DESC(n).fOptState &= OPTST_PERSISTENT_MASK;   \
                if ((DESC(n).fOptState & OPTST_INITENABLED) == 0) \
                    DESC(n).fOptState |= OPTST_DISABLED; \
                DESC(n).optCookie = NULL )

/* * * * * *
 *
 *  Enumeration of pcopy exit codes
 */
typedef enum {
    PCOPY_EXIT_SUCCESS = 0,
    PCOPY_EXIT_FAILURE = 1,
    PCOPY_EXIT_NO_MEM = 2,
    PCOPY_EXIT_FS_ERR_IN = 3,
    PCOPY_EXIT_FS_ERR_OUT = 4,
    PCOPY_EXIT_BAD_CONFIG = 5,
    PCOPY_EXIT_NO_CONFIG_INPUT = 66,
    PCOPY_EXIT_LIBOPTS_FAILURE = 70
} pcopy_exit_code_t;
/* * * * * *
 *
 *  Interface defines for specific options.
 */
#define VALUE_OPT_THREAD_CT      't'

#define OPT_VALUE_THREAD_CT      (DESC(THREAD_CT).optArg.argInt)
#define VALUE_OPT_FLOW_RATE      'f'

#define OPT_VALUE_FLOW_RATE      (DESC(FLOW_RATE).optArg.argInt)
#define VALUE_OPT_MAX_CHUNK      'c'

#define OPT_VALUE_MAX_CHUNK      (DESC(MAX_CHUNK).optArg.argInt)
#define SET_OPT_MAX_CHUNK(a)   STMTS( \
        DESC(MAX_CHUNK).optActualIndex = 3; \
        DESC(MAX_CHUNK).optActualValue = VALUE_OPT_MAX_CHUNK; \
        DESC(MAX_CHUNK).fOptState &= OPTST_PERSISTENT_MASK; \
        DESC(MAX_CHUNK).fOptState |= OPTST_SET; \
        DESC(MAX_CHUNK).optArg.argInt = (a); \
        (*(DESC(MAX_CHUNK).pOptProc))(&pcopyOptions, \
                pcopyOptions.pOptDesc + 3); )
#define VALUE_OPT_DESTINATION    'd'
#define VALUE_OPT_QUIET          'q'
#define VALUE_OPT_HELP          '?'
#define VALUE_OPT_MORE_HELP     '!'
#define VALUE_OPT_VERSION       'v'
#define VALUE_OPT_USAGE         'u'
#define VALUE_OPT_SAVE_OPTS     '>'
#define VALUE_OPT_LOAD_OPTS     '<'
#define SET_OPT_SAVE_OPTS(a)   STMTS( \
        DESC(SAVE_OPTS).fOptState &= OPTST_PERSISTENT_MASK; \
        DESC(SAVE_OPTS).fOptState |= OPTST_SET; \
        DESC(SAVE_OPTS).optArg.argString = (char const*)(a) )
/*
 *  Interface defines not associated with particular options
 */
#define ERRSKIP_OPTERR  STMTS(pcopyOptions.fOptSet &= ~OPTPROC_ERRSTOP)
#define ERRSTOP_OPTERR  STMTS(pcopyOptions.fOptSet |= OPTPROC_ERRSTOP)
#define RESTART_OPT(n)  STMTS( \
                pcopyOptions.curOptIdx = (n); \
                pcopyOptions.pzCurOpt  = NULL)
#define START_OPT       RESTART_OPT(1)
#define USAGE(c)        (*pcopyOptions.pUsageProc)(&pcopyOptions, c)
/* extracted from opthead.tlib near line 484 */

#ifdef  __cplusplus
extern "C" {
#endif
/*
 *  global exported definitions
 */
/*! @var List of pthreads doing the copies. */
extern pthread_t  *    pth_list;

/*! @var for accessing curses functions. */
extern pthread_mutex_t tty_mutex;

/*! @var Thread start is done condition variable.
 * The main thread must wait for each thread to open the input
 * and output files before starting the next thread.
 * Bad things happen if you do not wait.
 */
extern pthread_cond_t  th_start_cond;

/*! @var Condition variable accessor mutex. */
extern pthread_mutex_t th_start_mutex;

/*! @var Whether initscr() has been called.
 *  It is set false after a call to endwin(). */
extern bool            curses_active;

/*! @var minimum amount of time to consume per chunk.
 * If the flow-rate option has been specified, then this value is
 * computed based on that rate, the number of threads and the chunk
 * size.  The read thread sleeps if it finishes early.
 */
extern uint64_t        nsec_per_iteration;

/*! @var The size of the read for each iteration.
 * It is forced to be a multiple of the optimal size for a read.
 * That value is obtained from a stat() call.  The default value
 * is 16K (0x4000) bytes.
 */
extern unsigned long   iteration_chunk;

extern void vusage_message(char const * fmt, va_list ap);
extern void usage_message(char const * fmt, ...);


/* * * * * *
 *
 *  Declare the pcopy option descriptor.
 */
extern tOptions pcopyOptions;
# define OPT_NO_XLAT_CFG_NAMES
# define OPT_NO_XLAT_OPT_NAMES

# define OPT_XLAT_CFG_NAMES
# define OPT_XLAT_OPT_NAMES

# ifndef _
#   define _(_s)  _s
# endif

extern void vdie( int exit_code, char const * fmt, va_list);
extern void die(  int exit_code, char const * fmt, ...);
extern void fserr(int exit_code, char const * op, char const * fname);

#ifdef  __cplusplus
}
#endif
#endif /* AUTOOPTS_PCOPY_OPTS_H_GUARD */
/* pcopy-opts.h ends here */
pcopy.10000644000175000017500000001517411751317322010743 0ustar  bkorbdev.TH pcopy 1 "05 May 2012" "0.4" "User Commands"
.\"
.\"  DO NOT EDIT THIS FILE   (pcopy-opts.man)
.\"  
.\"  It has been AutoGen-ed  May  5, 2012 at 01:13:36 PM by AutoGen 5.16pre36
.\"  From the definitions    pcopy-opts.def
.\"  and the template file   agman-cmd.tpl
.\"
.SH NAME
pcopy \- Parallel copy
.SH SYNOPSIS
.B pcopy
.\" Mixture of short (flag) options and long options
.RB [ \-\fIflag\fP " [\fIvalue\fP]]... [" \-\-\fIopt\-name\fP " [[=| ]\fIvalue\fP]]..." [ <file> ... ]
.SH DESCRIPTION
This program is intended to copy a file between a network mounted file
system and local storage.  If you have a really large file (like a
crash dump or an ISO image), the \fBcp(1)\fP or even
\fBrsync(1)\fP programs can take an extrordinarly long time.  The
network link may be fast enough, but each piece of the file must be
acknowledged before the next piece is sent.  Several instances of
\fBdd(1)\fP ought to work, but on CIFS mounts, the instances that
need to seek to their assigned offset will often fail.
.sp
This program uses pthreads.  Each thread is assigned a segment of the
file to copy.  Each thread starts serially so that there is no
thundering herd of pthreads all trying to open the remote file at the
same time.  You wouldn't like it if it were to do so.  There is also a
\fBflow\-rate\fP option so that you can avoid clogging the capacity
of your network link.  (You will need to know your own limits, though,
because this program won't figure it out.)
.sp
.sp.Pp
This program will perform its function for every file named on the command
line or every file named in a list read from stdin.  The arguments or input
names must be pre\-existing files.  The input list may contain comments,
which are blank lines or lines beginning with a '#' character.
.SH "OPTIONS"
.SS "How many / how long / how much specifications"
.TP
.BR \-t " \fIcount\fP, " \-\-thread\-ct "=" \fIcount\fP
limit copy threads to \fBcount\fP.
This option takes an integer number as its argument.
The default \fIcount\fP for this option is:
.ti +4
 8
.sp
By default, 8 threads are run in parallel.  The file is divided into
roughly 8 equal pieces, with each a multiple of the optimal transfer
size.  The read threads and write threads each open an independent
file pointer, seek to the appropriate offset and start copying.
.TP
.BR \-f " \fIbytes\fP, " \-\-flow\-rate "=" \fIbytes\fP
maximum \fBbytes\fP per second flow.
This option takes an integer number as its argument.
.sp
Constrain aggregate transfer rate to so many bytes per second.
For a 10 megabit pipe, half capacity is about 500K bytes per second.
Each thread will be constrained to its portion of the total.
.TP
.BR \-c " \fIbytes\fP, " \-\-max\-chunk "=" \fIbytes\fP
maximum \fBbytes\fP per read chunk.
This option takes an integer number as its argument.
The default \fIbytes\fP for this option is:
.ti +4
 16384
.sp
Constrain each transfer to not more than \fIbytes\fP of data.
.SS "Where to put the output"
.TP
.BR \-d " \fIdest\fP, " \-\-destination "=" \fIdest\fP
Copy files to the \fBdest\fP destination.
.sp
By default, the source file[s] is [are] copied to the current directory.
If you are copying from multiple sources, you must ensure that there are
not any name conflicts.  With this option, you can specify an alternate
destination directory or the full output file name.  If the destination
file exists, it is removed before copying begins.  If there are multiple
input files, then this option must specify a directory.
.SS "User information"
.TP
.BR \-q ", " -\-quiet
omit progress output.
.sp
Normally, each thread prints its progress as each read finishes.
The entire screen is taken over and each thread is assigned a line
for its output.  This will suppress that.
.TP
.BR \-? , " \-\-help"
Display usage information and exit.
.TP
.BR \-! , " \-\-more-help"
Pass the extended usage information through a pager.
.TP
.BR \-> " [\fIrcfile\fP]," " \-\-save-opts" "[=\fIrcfile\fP]"
Save the option state to \fIrcfile\fP.  The default is the \fIlast\fP
configuration file listed in the \fBOPTION PRESETS\fP section, below.
.TP
.BR \-< " \fIrcfile\fP," " \-\-load-opts" "=\fIrcfile\fP," " \-\-no-load-opts"
Load options from \fIrcfile\fP.
The \fIno-load-opts\fP form will disable the loading
of earlier RC/INI files.  \fI\-\-no-load-opts\fP is handled early,
out of order.
.TP
.BR \-v " [{\fIv|c|n\fP}]," " \-\-version" "[=\fI{v|c|n}\fP]"
Output version of program and exit.  The default mode is `v', a simple
version.  The `c' mode will print copyright information and `n' will
print the full copyright notice.
.SH "OPTION PRESETS"
Any option that is not marked as \fInot presettable\fP may be preset
by loading values from configuration ("RC" or ".INI") file(s) and values from
environment variables named:
.nf
  \fBPCOPY_<option-name>\fP or \fBPCOPY\fP
.fi
.ad
The environmental presets take precedence (are processed later than)
the configuration files.
The \fIhomerc\fP files are "\fI$HOME\fP", and "\fI.\fP".
If any of these are directories, then the file \fI.pcopyrc\fP
is searched for within those directories.
.SH "ENVIRONMENT"
See \fBOPTION PRESETS\fP for configuration environment variables.
.SH "FILES"
See \fBOPTION PRESETS\fP for configuration files.
.SH EXAMPLES
.br
.in +4
.nf
\fBpcopy\fP \fB\-\-flow\-rate\fP=500k \fB\-\-thread\-ct\fP=16 \fI/path/to/large.iso\fP
.in -4
.fi
.sp
This command will copy \fIlarge.iso\fP to the current directory.
It will self\-limit to 500,000 bytes per second, or about half of
a 10 megabit connection.  The copy operation will be split up into
16 different sections with each read and write operation constrained
to the default maximum chunk size of 16K (16384) bytes.
.SH "EXIT STATUS"
One of the following exit values will be returned:
.TP
.BR 0 " (EXIT_SUCCESS)"
Successful program execution.
.TP
.BR 1 " (EXIT_FAILURE)"
The operation failed or the command syntax was not valid.
.TP
.BR 2 " (EXIT_NO_MEM)"
Insufficient memory to operate
.TP
.BR 3 " (EXIT_FS_ERR_IN)"
File system error accessing source
.TP
.BR 4 " (EXIT_FS_ERR_OUT)"
File system error writing output
.TP
.BR 5 " (EXIT_BAD_CONFIG)"
The specified configuration is \fInot supported\fP
.TP
.BR 66 " (EX_NOINPUT)"
A specified configuration file could not be loaded.
.TP
.BR 70 " (EX_SOFTWARE)"
libopts had an internal operational error.  Please report
it to autogen-users@lists.sourceforge.net.  Thank you.
.SH "SEE ALSO"
cp(1), rsync(1) and dd(1)
.SH "AUTHORS"
Bruce Korb
.SH "COPYRIGHT"
Copyright (C) 2012 Bruce Korb all rights reserved.
This program is released under the terms of the GNU General Public License, version 3 or later.
.SH "BUGS"
Please send bug reports to: autogen-users@lists.sourceforge.net
.SH "NOTES"
This manual page was \fIAutoGen\fP-erated from the \fBpcopy\fP
option definitions.
pcopy.texi0000644000175000017500000002701711751317322011553 0ustar  bkorbdev\input texinfo
@c -*-texinfo-*-
@c %**start of header
@setfilename pcopy.info
@settitle 
@c %**end of header
@setchapternewpage off
@titlepage
@sp 10
@comment The title is printed in a large font.
@center @titlefont{Sample Title}

@c The following two commands start the copyright page.
@page
@vskip 0pt plus 1filll

This software is released under the GNU General Public License, version 3 or later.
Copyright (C) 2012 Bruce Korb, all rights reserved.
This is free software. It is licensed for use, modification and
redistribution under the terms of the
GNU General Public License, version 3 or later
    <http://gnu.org/licenses/gpl.html>

pcopy is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

pcopy is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along
with this program.  If not, see <http://www.gnu.org/licenses/>.
@end titlepage
@node Top, pcopy usage, , (dir)
@top Parallel copy

@ignore
#  -*- buffer-read-only: t -*- vi: set ro:
# 
# DO NOT EDIT THIS FILE   (pcopy.texi)
# 
# It has been AutoGen-ed  May  5, 2012 at 01:13:37 PM by AutoGen 5.16pre36
# From the definitions    pcopy-opts.def
# and the template file   agtexi-cmd
@end ignore

This program is intended to copy a file between a network mounted file
system and local storage.  If you have a really large file (like a
crash dump or an ISO image), the @command{cp(1)} or even
@command{rsync(1)} programs can take an extrordinarly long time.  The
network link may be fast enough, but each piece of the file must be
acknowledged before the next piece is sent.  Several instances of
@command{dd(1)} ought to work, but on CIFS mounts, the instances that
need to seek to their assigned offset will often fail.

This program uses pthreads.  Each thread is assigned a segment of the
file to copy.  Each thread starts serially so that there is no
thundering herd of pthreads all trying to open the remote file at the
same time.  You wouldn't like it if it were to do so.  There is also a
@command{flow-rate} option so that you can avoid clogging the capacity
of your network link.  (You will need to know your own limits, though,
because this program won't figure it out.)




This document was generated by @strong{AutoGen},
using the @code{agtexi-cmd} template and the option descriptions for the @code{pcopy} program.
This software is released under the GNU General Public License, version 3 or later.

@menu
* pcopy usage::                  pcopy help/usage (-?)
* pcopy limits::                 limits options
* pcopy where::                  where options
* pcopy information::            information options
* pcopy config::                 presetting/configuring pcopy
* pcopy exit status::            exit status
* pcopy See Also::               See Also
* pcopy Examples::               Examples
@end menu

@node pcopy usage
@chapter pcopy help/usage (-?)
@cindex pcopy help

This is the automatically generated usage text for pcopy.
The text printed is the same whether for the @code{help} option (-?) or the @code{more-help} option (-!).  @code{more-help} will print
the usage text by passing it through a pager program.
@code{more-help} is disabled on platforms without a working
@code{fork(2)} function.  The @code{PAGER} environment variable is
used to select the program, defaulting to @file{more}.  Both will exit
with a status code of 0.

@exampleindent 0
@example
pcopy - Parallel copy - Ver. 0.4
USAGE:  pcopy [ -<flag> [<val>] | --<name>[@{=| @}<val>] ]... [ <file> ... ]

How many / how long / how much specifications:

  Flg Arg Option-Name    Description
   -t Num thread-ct      limit copy threads to count
   -f Num flow-rate      maximum bytes per second flow
   -c Num max-chunk      maximum bytes per read chunk

Where to put the output:

  Flg Arg Option-Name    Description
   -d Str destination    Copy files to the dest destination

User information:

  Flg Arg Option-Name    Description
   -q no  quiet          omit progress output

version, usage and configuration options:

  Flg Arg Option-Name    Description
   -v opt version        Output version information and exit
   -? no  help           Display extended usage information and exit
   -u no  usage          Abbreviated usage to stdout
   -> opt save-opts      Save the option state to a config file
   -< Str load-opts      Load options from a config file
                                - disabled as --no-load-opts
                                - may appear multiple times

Options are specified by doubled hyphens and their name or by a single
hyphen and the flag character.

If no arguments are provided, input arguments are read from stdin,
one per line; blank and '#'-prefixed lines are comments.
'stdin' may not be a terminal (tty).

The following option preset mechanisms are supported:
 - reading file $HOME/.pcopyrc
 - reading file ./.pcopyrc
 - examining environment variables named PCOPY_*

Copy a file in several chunks in parallel.

please send bug reports to:  autogen-users@@lists.sourceforge.net
@end example
@exampleindent 4

@node pcopy limits
@chapter limits options
How many / how long / how much specifications.
@heading thread-ct option (-t).
@anchor{pcopy thread-ct}
@cindex pcopy-thread-ct

This is the ``limit copy threads to @code{count}'' option.
This option takes an argument number @file{count}.
By default, 8 threads are run in parallel.  The file is divided into
roughly 8 equal pieces, with each a multiple of the optimal transfer
size.  The read threads and write threads each open an independent
file pointer, seek to the appropriate offset and start copying.
@heading flow-rate option (-f).
@anchor{pcopy flow-rate}
@cindex pcopy-flow-rate

This is the ``maximum @code{bytes} per second flow'' option.
This option takes an argument number @file{bytes}.
Constrain aggregate transfer rate to so many bytes per second.
For a 10 megabit pipe, half capacity is about 500K bytes per second.
Each thread will be constrained to its portion of the total.
@heading max-chunk option (-c).
@anchor{pcopy max-chunk}
@cindex pcopy-max-chunk

This is the ``maximum @code{bytes} per read chunk'' option.
This option takes an argument number @file{bytes}.
Constrain each transfer to not more than @i{bytes} of data.
@node pcopy where
@chapter where options
Where to put the output.
@heading destination option (-d).
@anchor{pcopy destination}
@cindex pcopy-destination

This is the ``copy files to the @code{dest} destination'' option.
This option takes an argument string @file{dest}.
By default, the source file[s] is [are] copied to the current directory.
If you are copying from multiple sources, you must ensure that there are
not any name conflicts.  With this option, you can specify an alternate
destination directory or the full output file name.  If the destination
file exists, it is removed before copying begins.  If there are multiple
input files, then this option must specify a directory.
@node pcopy information
@chapter information options
User information.
@heading quiet option (-q).
@anchor{pcopy quiet}
@cindex pcopy-quiet

This is the ``omit progress output'' option.
Normally, each thread prints its progress as each read finishes.
The entire screen is taken over and each thread is assigned a line
for its output.  This will suppress that.


@node pcopy config
@chapter presetting/configuring pcopy

Any option that is not marked as @i{not presettable} may be preset by
loading values from configuration ("rc" or "ini") files, and values from environment variables named @code{PCOPY} and @code{PCOPY_<OPTION_NAME>}.  @code{<OPTION_NAME>} must be one of
the options listed above in upper case and segmented with underscores.
The @code{PCOPY} variable will be tokenized and parsed like
the command line.  The remaining variables are tested for existence and their
values are treated like option arguments.


@noindent
@code{libopts} will search in 2 places for configuration files:
@itemize @bullet
@item
$HOME
@item
$PWD
@end itemize
The environment variables @code{HOME}, and @code{PWD}
are expanded and replaced when @file{pcopy} runs.
For any of these that are plain files, they are simply processed.
For any that are directories, then a file named @file{.pcopyrc} is searched for
within that directory and processed.


Configuration files may be in a wide variety of formats.
The basic format is an option name followed by a value (argument) on the
same line.  Values may be separated from the option name with a colon,
equal sign or simply white space.  Values may be continued across multiple
lines by escaping the newline with a backslash.

Multiple programs may also share the same initialization file.
Common options are collected at the top, followed by program specific
segments.  The segments are separated by lines like:
@example
[PCOPY]
@end example
@noindent
or by
@example
<?program pcopy>
@end example
@noindent
Do not mix these styles within one configuration file.

Compound values and carefully constructed string values may also be
specified using XML syntax:
@example
<option-name>
   <sub-opt>...&lt;...&gt;...</sub-opt>
</option-name>
@end example
@noindent
yielding an @code{option-name.sub-opt} string value of
@example
"...<...>..."
@end example
@code{AutoOpts} does not track suboptions.  You simply note that it is a
hierarchicly valued option.  @code{AutoOpts} does provide a means for searching
the associated name/value pair list (see: optionFindValue).

The command line options relating to configuration and/or usage help are:

@heading version (-v)

Print the program version to standard out, optionally with licensing
information, then exit 0.  The optional argument specifies how much licensing
detail to provide.  The default is to print just the version.  The licensing infomation may be selected with an option argument.  Only the
first letter of the argument is examined:

@table @samp
@item version
Only print the version.  This is the default.
@item copyright
Name the copyright usage licensing terms.
@item verbose
Print the full copyright usage licensing terms.
@end table

@heading usage (-u)

Print abbreviated usage to standard out, then exit 0.

@node pcopy exit status
@chapter pcopy exit status

One of the following exit values will be returned:
@table @samp
@item 0 (EXIT_SUCCESS)
Successful program execution.
@item 1 (EXIT_FAILURE)
The operation failed or the command syntax was not valid.
@item 2 (EXIT_NO_MEM)
Insufficient memory to operate
@item 3 (EXIT_FS_ERR_IN)
File system error accessing source
@item 4 (EXIT_FS_ERR_OUT)
File system error writing output
@item 5 (EXIT_BAD_CONFIG)
The specified configuration is @i{not supported}
@item 66 (EX_NOINPUT)
A specified configuration file could not be loaded.
@item 70 (EX_SOFTWARE)
libopts had an internal operational error.  Please report
it to autogen-users@@lists.sourceforge.net.  Thank you.
@end table
@node pcopy See Also
@chapter pcopy See Also
cp(1), rsync(1) and dd(1)

@node pcopy Examples
@chapter pcopy Examples
@example
@command{pcopy} @option{--flow-rate}=500k @option{--thread-ct}=16 @file{/path/to/large.iso}
@end example

This command will copy @file{large.iso} to the current directory.
It will self-limit to 500,000 bytes per second, or about half of
a 10 megabit connection.  The copy operation will be split up into
16 different sections with each read and write operation constrained
to the default maximum chunk size of 16K (16384) bytes.

pcopy.info0000644000175000017500000002514111751317322011531 0ustar  bkorbdevThis is pcopy.info, produced by makeinfo version 4.13 from pcopy.texi.


File: pcopy.info,  Node: Top,  Next: pcopy usage,  Up: (dir)

Parallel copy
*************

This program is intended to copy a file between a network mounted file
system and local storage.  If you have a really large file (like a
crash dump or an ISO image), the `cp(1)' or even `rsync(1)' programs
can take an extrordinarly long time.  The network link may be fast
enough, but each piece of the file must be acknowledged before the next
piece is sent.  Several instances of `dd(1)' ought to work, but on CIFS
mounts, the instances that need to seek to their assigned offset will
often fail.

   This program uses pthreads.  Each thread is assigned a segment of the
file to copy.  Each thread starts serially so that there is no
thundering herd of pthreads all trying to open the remote file at the
same time.  You wouldn't like it if it were to do so.  There is also a
`flow-rate' option so that you can avoid clogging the capacity of your
network link.  (You will need to know your own limits, though, because
this program won't figure it out.)

   This document was generated by *AutoGen*, using the `agtexi-cmd'
template and the option descriptions for the `pcopy' program.  This
software is released under the GNU General Public License, version 3 or
later.

* Menu:

* pcopy usage::                  pcopy help/usage (-?)
* pcopy limits::                 limits options
* pcopy where::                  where options
* pcopy information::            information options
* pcopy config::                 presetting/configuring pcopy
* pcopy exit status::            exit status
* pcopy See Also::               See Also
* pcopy Examples::               Examples


File: pcopy.info,  Node: pcopy usage,  Next: pcopy limits,  Prev: Top,  Up: Top

1 pcopy help/usage (-?)
***********************

This is the automatically generated usage text for pcopy.  The text
printed is the same whether for the `help' option (-?) or the
`more-help' option (-!).  `more-help' will print the usage text by
passing it through a pager program.  `more-help' is disabled on
platforms without a working `fork(2)' function.  The `PAGER'
environment variable is used to select the program, defaulting to
`more'.  Both will exit with a status code of 0.

pcopy - Parallel copy - Ver. 0.4
USAGE:  pcopy [ -<flag> [<val>] | --<name>[{=| }<val>] ]... [ <file> ... ]

How many / how long / how much specifications:

  Flg Arg Option-Name    Description
   -t Num thread-ct      limit copy threads to count
   -f Num flow-rate      maximum bytes per second flow
   -c Num max-chunk      maximum bytes per read chunk

Where to put the output:

  Flg Arg Option-Name    Description
   -d Str destination    Copy files to the dest destination

User information:

  Flg Arg Option-Name    Description
   -q no  quiet          omit progress output

version, usage and configuration options:

  Flg Arg Option-Name    Description
   -v opt version        Output version information and exit
   -? no  help           Display extended usage information and exit
   -u no  usage          Abbreviated usage to stdout
   -> opt save-opts      Save the option state to a config file
   -< Str load-opts      Load options from a config file
                                - disabled as --no-load-opts
                                - may appear multiple times

Options are specified by doubled hyphens and their name or by a single
hyphen and the flag character.

If no arguments are provided, input arguments are read from stdin,
one per line; blank and '#'-prefixed lines are comments.
'stdin' may not be a terminal (tty).

The following option preset mechanisms are supported:
 - reading file $HOME/.pcopyrc
 - reading file ./.pcopyrc
 - examining environment variables named PCOPY_*

Copy a file in several chunks in parallel.

please send bug reports to:  autogen-users@lists.sourceforge.net


File: pcopy.info,  Node: pcopy limits,  Next: pcopy where,  Prev: pcopy usage,  Up: Top

2 limits options
****************

How many / how long / how much specifications.

thread-ct option (-t).
======================

This is the "limit copy threads to `count'" option.  This option takes
an argument number `count'.  By default, 8 threads are run in parallel.
The file is divided into roughly 8 equal pieces, with each a multiple
of the optimal transfer size.  The read threads and write threads each
open an independent file pointer, seek to the appropriate offset and
start copying.

flow-rate option (-f).
======================

This is the "maximum `bytes' per second flow" option.  This option
takes an argument number `bytes'.  Constrain aggregate transfer rate to
so many bytes per second.  For a 10 megabit pipe, half capacity is
about 500K bytes per second.  Each thread will be constrained to its
portion of the total.

max-chunk option (-c).
======================

This is the "maximum `bytes' per read chunk" option.  This option takes
an argument number `bytes'.  Constrain each transfer to not more than
bytes of data.


File: pcopy.info,  Node: pcopy where,  Next: pcopy information,  Prev: pcopy limits,  Up: Top

3 where options
***************

Where to put the output.

destination option (-d).
========================

This is the "copy files to the `dest' destination" option.  This option
takes an argument string `dest'.  By default, the source file[s] is
[are] copied to the current directory.  If you are copying from
multiple sources, you must ensure that there are not any name
conflicts.  With this option, you can specify an alternate destination
directory or the full output file name.  If the destination file
exists, it is removed before copying begins.  If there are multiple
input files, then this option must specify a directory.


File: pcopy.info,  Node: pcopy information,  Next: pcopy config,  Prev: pcopy where,  Up: Top

4 information options
*********************

User information.

quiet option (-q).
==================

This is the "omit progress output" option.  Normally, each thread
prints its progress as each read finishes.  The entire screen is taken
over and each thread is assigned a line for its output.  This will
suppress that.


File: pcopy.info,  Node: pcopy config,  Next: pcopy exit status,  Prev: pcopy information,  Up: Top

5 presetting/configuring pcopy
******************************

Any option that is not marked as not presettable may be preset by
loading values from configuration ("rc" or "ini") files, and values
from environment variables named `PCOPY' and `PCOPY_<OPTION_NAME>'.
`<OPTION_NAME>' must be one of the options listed above in upper case
and segmented with underscores.  The `PCOPY' variable will be tokenized
and parsed like the command line.  The remaining variables are tested
for existence and their values are treated like option arguments.

`libopts' will search in 2 places for configuration files:
   * $HOME

   * $PWD
   The environment variables `HOME', and `PWD' are expanded and
replaced when `pcopy' runs.  For any of these that are plain files,
they are simply processed.  For any that are directories, then a file
named `.pcopyrc' is searched for within that directory and processed.

   Configuration files may be in a wide variety of formats.  The basic
format is an option name followed by a value (argument) on the same
line.  Values may be separated from the option name with a colon, equal
sign or simply white space.  Values may be continued across multiple
lines by escaping the newline with a backslash.

   Multiple programs may also share the same initialization file.
Common options are collected at the top, followed by program specific
segments.  The segments are separated by lines like:
    [PCOPY]
   or by
    <?program pcopy>
   Do not mix these styles within one configuration file.

   Compound values and carefully constructed string values may also be
specified using XML syntax:
    <option-name>
       <sub-opt>...&lt;...&gt;...</sub-opt>
    </option-name>
   yielding an `option-name.sub-opt' string value of
    "...<...>..."
   `AutoOpts' does not track suboptions.  You simply note that it is a
hierarchicly valued option.  `AutoOpts' does provide a means for
searching the associated name/value pair list (see: optionFindValue).

   The command line options relating to configuration and/or usage help
are:

version (-v)
============

Print the program version to standard out, optionally with licensing
information, then exit 0.  The optional argument specifies how much
licensing detail to provide.  The default is to print just the version.
The licensing infomation may be selected with an option argument.  Only
the first letter of the argument is examined:

`version'
     Only print the version.  This is the default.

`copyright'
     Name the copyright usage licensing terms.

`verbose'
     Print the full copyright usage licensing terms.

usage (-u)
==========

Print abbreviated usage to standard out, then exit 0.


File: pcopy.info,  Node: pcopy exit status,  Next: pcopy See Also,  Prev: pcopy config,  Up: Top

6 pcopy exit status
*******************

One of the following exit values will be returned:
`0 (EXIT_SUCCESS)'
     Successful program execution.

`1 (EXIT_FAILURE)'
     The operation failed or the command syntax was not valid.

`2 (EXIT_NO_MEM)'
     Insufficient memory to operate

`3 (EXIT_FS_ERR_IN)'
     File system error accessing source

`4 (EXIT_FS_ERR_OUT)'
     File system error writing output

`5 (EXIT_BAD_CONFIG)'
     The specified configuration is not supported

`66 (EX_NOINPUT)'
     A specified configuration file could not be loaded.

`70 (EX_SOFTWARE)'
     libopts had an internal operational error.  Please report it to
     autogen-users@lists.sourceforge.net.  Thank you.


File: pcopy.info,  Node: pcopy See Also,  Next: pcopy Examples,  Prev: pcopy exit status,  Up: Top

7 pcopy See Also
****************

cp(1), rsync(1) and dd(1)


File: pcopy.info,  Node: pcopy Examples,  Prev: pcopy See Also,  Up: Top

8 pcopy Examples
****************

    `pcopy' `--flow-rate'=500k `--thread-ct'=16 `/path/to/large.iso'

   This command will copy `large.iso' to the current directory.  It
will self-limit to 500,000 bytes per second, or about half of a 10
megabit connection.  The copy operation will be split up into 16
different sections with each read and write operation constrained to
the default maximum chunk size of 16K (16384) bytes.



Tag Table:
Node: Top0
Node: pcopy usage1741
Node: pcopy limits3938
Ref: pcopy thread-ct4159
Ref: pcopy flow-rate4575
Ref: pcopy max-chunk4920
Node: pcopy where5078
Ref: pcopy destination5285
Node: pcopy information5812
Ref: pcopy quiet6012
Node: pcopy config6232
Node: pcopy exit status9007
Node: pcopy See Also9807
Node: pcopy Examples9971

End Tag Table