[sgt/utils] / xcopy / xcopy.c

/*
 * xcopy: quickly pipe text data into, or out of, the primary X
 * selection
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <math.h>
#include <errno.h>
#include <assert.h>

#include <X11/X.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xatom.h>

int init_X(void);
void run_X(void);
void done_X(void);
void full_redraw(void);
void do_paste(Window window, Atom property, int Delete);

char *pname;			       /* program name */

void error (char *fmt, ...);

/* set from command-line parameters */
char *display = NULL;
enum { STRING, CTEXT, UTF8, TARGETS, TIMESTAMP, CUSTOM } mode = STRING;
int use_clipboard = False;
char *custom_seltype = NULL;
int fork_when_writing = True;

/* selection data */
char *seltext;
int sellen, selsize;
#define SELDELTA 16384

/* functional parameters */
int reading;                           /* read instead of writing? */
int convert_to_ctext = True;	       /* Xmb convert to compound text? */

const char usagemsg[] =
    "usage: xcopy [ -r ] [ -u | -c ] [ -C ]\n"
    "where: -r       read X selection and print on stdout\n"
    "       no -r    read stdin and store in X selection\n"
    "       -u       work with UTF8_STRING type selections\n"
    "       -c       work with COMPOUND_TEXT type selections\n"
    "       -C       suppress automatic conversion to COMPOUND_TEXT\n"
    "       -b       read the CLIPBOARD rather than the PRIMARY selection\n"
    "       -t       get the list of targets available to retrieve\n"
    "       -T       get the time stamp of the selection contents\n"
    "       -a atom  get an arbitrary form of the selection data\n"
    "       -F       do not fork in write mode\n"
    " also: xcopy --version              report version number\n"
    "       xcopy --help                 display this help text\n"
    "       xcopy --licence              display the (MIT) licence text\n"
    ;

void usage(void) {
    fputs(usagemsg, stdout);
}

const char licencemsg[] =
    "xcopy is copyright 2001-2004 Simon Tatham.\n"
    "\n"
    "Permission is hereby granted, free of charge, to any person\n"
    "obtaining a copy of this software and associated documentation files\n"
    "(the \"Software\"), to deal in the Software without restriction,\n"
    "including without limitation the rights to use, copy, modify, merge,\n"
    "publish, distribute, sublicense, and/or sell copies of the Software,\n"
    "and to permit persons to whom the Software is furnished to do so,\n"
    "subject to the following conditions:\n"
    "\n"
    "The above copyright notice and this permission notice shall be\n"
    "included in all copies or substantial portions of the Software.\n"
    "\n"
    "THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n"
    "EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n"
    "MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\n"
    "NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\n"
    "BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\n"
    "ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\n"
    "CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n"
    "SOFTWARE.\n"
    ;

void licence(void) {
    fputs(licencemsg, stdout);
}

void version(void) {
#define SVN_REV "$Revision$"
    char rev[sizeof(SVN_REV)];
    char *p, *q;

    strcpy(rev, SVN_REV);

    for (p = rev; *p && *p != ':'; p++);
    if (*p) {
        p++;
        while (*p && isspace(*p)) p++;
        for (q = p; *q && *q != '$'; q++);
        if (*q) *q = '\0';
        printf("xcopy revision %s\n", p);
    } else {
        printf("xcopy: unknown version\n");
    }
}

int main(int ac, char **av) {
    int n;
    int eventloop;

    pname = *av;

    /* parse the command line arguments */
    while (--ac > 0) {
	char *p = *++av;

	if (!strcmp(p, "-display") || !strcmp(p, "-disp")) {
	    if (!av[1])
		error ("option `%s' expects a parameter", p);
	    display = *++av, --ac;
        } else if (!strcmp(p, "-r")) {
            reading = True;
        } else if (!strcmp(p, "-u")) {
            mode = UTF8;
        } else if (!strcmp(p, "-c")) {
            mode = CTEXT;
        } else if (!strcmp(p, "-C")) {
            convert_to_ctext = False;
        } else if (!strcmp(p, "-b")) {
            use_clipboard = True;
        } else if (!strcmp(p, "-t")) {
            mode = TARGETS;
        } else if (!strcmp(p, "-T")) {
            mode = TIMESTAMP;
        } else if (!strcmp(p, "-a")) {
	    if (--ac > 0)
		custom_seltype = *++av;
	    else
		error ("expected an argument to `-a'");
            mode = CUSTOM;
	} else if (!strcmp(p, "-F")) {
	    fork_when_writing = False;
        } else if (!strcmp(p, "--help")) {
	    usage();
	    return 0;
        } else if (!strcmp(p, "--version")) {
            version();
	    return 0;
        } else if (!strcmp(p, "--licence") || !strcmp(p, "--license")) {
            licence();
	    return 0;
	} else if (*p=='-') {
	    error ("unrecognised option `%s'", p);
	} else {
	    error ("no parameters required");
	}
    }

    if (!reading) {
	if (mode == TARGETS || mode == TIMESTAMP || mode == CUSTOM) {
	    error ("%s not supported in writing mode; use -r",
		   (mode == TARGETS ? "-t" :
		    mode == TIMESTAMP ? "-T" :
		    /* mode == CUSTOM ? */ "-a"));
	}
    }

    if (!reading) {
        seltext = malloc(SELDELTA);
        if (!seltext)
            error ("out of memory");
        selsize = SELDELTA;
        sellen = 0;
        do {
            n = fread(seltext+sellen, 1, selsize-sellen, stdin);
            sellen += n;
            if (sellen >= selsize) {
                seltext = realloc(seltext, selsize += SELDELTA);
                if (!seltext)
                    error ("out of memory");
            }
        } while (n > 0);
        if (sellen == selsize) {
            seltext = realloc(seltext, selsize += SELDELTA);
            if (!seltext)
                error ("out of memory");
        }
        seltext[sellen] = '\0';
    }

    eventloop = init_X();
    if (!reading && fork_when_writing) {
        /*
         * If we are writing the selection, we must go into the
         * background now.
         */
        int pid = fork();
        if (pid < 0) {
            error("unable to fork: %s", strerror(errno));
        } else if (pid > 0) {
            /*
             * we are the parent; just exit
             */
            return 0;
        }
        /*
         * we are the child
         */
        close(0);
        close(1);
        close(2);
        chdir("/");
    }
    if (eventloop)
        run_X();
    done_X();
    return 0;
}

/* handle errors */

void error (char *fmt, ...) {
    va_list ap;
    char errbuf[200];

    done_X();
    va_start (ap, fmt);
    vsprintf (errbuf, fmt, ap);
    va_end (ap);
    fprintf (stderr, "%s: %s\n", pname, errbuf);
    exit (1);
}

/* begin the X interface */

char *lcasename = "xcopy";
char *ucasename = "XCopy";

Display *disp = NULL;
Window ourwin = None;
Atom compound_text_atom, targets_atom, timestamp_atom, atom_atom, integer_atom;
Atom multiple_atom, atom_pair_atom;
int screen, wwidth, wheight;

Atom strtype = XA_STRING;
Atom sel_atom = XA_PRIMARY;
Atom expected_type = (Atom)None;
int expected_format = 8;

/*
 * Returns TRUE if we need to enter an event loop, FALSE otherwise.
 */
int init_X(void) {
    Window root;
    int x = 0, y = 0, width = 512, height = 128;
    int i, got = 0;
    XWMHints wm_hints;
    XSizeHints size_hints;
    XClassHint class_hints;
    XTextProperty textprop;
    XGCValues gcv;

    /* open the X display */
    disp = XOpenDisplay (display);
    if (!disp)
	error ("unable to open display");

    targets_atom = XInternAtom(disp, "TARGETS", False);
    timestamp_atom = XInternAtom(disp, "TIMESTAMP", False);
    atom_atom = XInternAtom(disp, "ATOM", False);
    atom_pair_atom = XInternAtom(disp, "ATOM_PAIR", False);
    multiple_atom = XInternAtom(disp, "MULTIPLE", False);
    integer_atom = XInternAtom(disp, "INTEGER", False);
    if (mode == UTF8) {
	strtype = XInternAtom(disp, "UTF8_STRING", False);
    } else if (mode == CTEXT) {
	strtype = XInternAtom(disp, "COMPOUND_TEXT", False);
    } else if (mode == TARGETS) {
	strtype = targets_atom;
	expected_type = atom_atom;
	expected_format = 32;
    } else if (mode == TIMESTAMP) {
	strtype = timestamp_atom;
	expected_type = integer_atom;
	expected_format = 32;
    } else if (mode == CUSTOM) {
	strtype = XInternAtom(disp, custom_seltype, True);
	if (!strtype)
	    error ("atom '%s' does not exist on the server", custom_seltype);
	expected_format = 0;
    }
    if (use_clipboard) {
        sel_atom = XInternAtom(disp, "CLIPBOARD", False);
    }

    /* get the screen and root-window */
    screen = DefaultScreen (disp);
    root = RootWindow (disp, screen);

    x = y = 0;
    width = height = 10;	       /* doesn't really matter */

    /* actually create the window */
    ourwin = XCreateSimpleWindow (disp, root, x, y, width, height,0, 
				  BlackPixel(disp, screen),
				  WhitePixel(disp, screen));

    /* resource class name */
    class_hints.res_name = lcasename;
    class_hints.res_class = ucasename;
    XSetClassHint (disp, ourwin, &class_hints);

    /* do selection fiddling */
    if (reading) {
        /*
         * We are reading the selection, so we must FIXME.
         */
        if (XGetSelectionOwner(disp, sel_atom) == None) {
            /* No primary selection, so use the cut buffer. */
            if (strtype == XA_STRING)
		do_paste(DefaultRootWindow(disp), XA_CUT_BUFFER0, False);
            return False;
        } else {
            Atom sel_property = XInternAtom(disp, "VT_SELECTION", False);
            XConvertSelection(disp, sel_atom, strtype,
                              sel_property, ourwin, CurrentTime);
            return True;
        }
    } else {
        /*
         * We are writing to the selection, so we establish
         * ourselves as selection owner. Also place the data in
         * CUT_BUFFER0, if it isn't of an exotic type (cut buffers
         * can only take ordinary string data, it turns out).
         */
        XSetSelectionOwner (disp, sel_atom, ourwin, CurrentTime);
        if (XGetSelectionOwner (disp, sel_atom) != ourwin)
            error ("unable to obtain primary X selection\n");
        compound_text_atom = XInternAtom(disp, "COMPOUND_TEXT", False);
	if (strtype == XA_STRING) {
	    /*
	     * ICCCM-required cut buffer initialisation.
	     */
	    XChangeProperty(disp, root, XA_CUT_BUFFER0,
			    XA_STRING, 8, PropModeAppend, "", 0);
	    XChangeProperty(disp, root, XA_CUT_BUFFER1,
			    XA_STRING, 8, PropModeAppend, "", 0);
	    XChangeProperty(disp, root, XA_CUT_BUFFER2,
			    XA_STRING, 8, PropModeAppend, "", 0);
	    XChangeProperty(disp, root, XA_CUT_BUFFER3,
			    XA_STRING, 8, PropModeAppend, "", 0);
	    XChangeProperty(disp, root, XA_CUT_BUFFER4,
			    XA_STRING, 8, PropModeAppend, "", 0);
	    XChangeProperty(disp, root, XA_CUT_BUFFER5,
			    XA_STRING, 8, PropModeAppend, "", 0);
	    XChangeProperty(disp, root, XA_CUT_BUFFER6,
			    XA_STRING, 8, PropModeAppend, "", 0);
	    XChangeProperty(disp, root, XA_CUT_BUFFER7,
			    XA_STRING, 8, PropModeAppend, "", 0);
	    /*
	     * Rotate the cut buffers and add our text in CUT_BUFFER0.
	     */
	    XRotateBuffers(disp, 1);
	    XStoreBytes(disp, seltext, sellen);
	}
        return True;
    }
}

Atom convert_sel_inner(Window requestor, Atom target, Atom property) {
    if (target == strtype) {
	XChangeProperty (disp, requestor, property, strtype,
			 8, PropModeReplace, seltext, sellen);
	return property;
    } else if (target == compound_text_atom && convert_to_ctext) {
	XTextProperty tp;
	XmbTextListToTextProperty (disp, &seltext, 1,
				   XCompoundTextStyle, &tp);
	XChangeProperty (disp, requestor, property, target,
			 tp.format, PropModeReplace,
			 tp.value, tp.nitems);
	return property;
    } else if (target == targets_atom) {
	Atom targets[16];
	int len = 0;
	targets[len++] = timestamp_atom;
	targets[len++] = targets_atom;
	targets[len++] = multiple_atom;
	targets[len++] = strtype;
	if (strtype != compound_text_atom && convert_to_ctext)
	    targets[len++] = compound_text_atom;
	XChangeProperty (disp, requestor, property,
			 atom_atom, 32, PropModeReplace,
			 (unsigned char *)targets, len);
	return property;
    } else if (target == timestamp_atom) {
	Time rettime = CurrentTime;
	XChangeProperty (disp, requestor, property,
			 integer_atom, 32, PropModeReplace,
			 (unsigned char *)&rettime, 1);
	return property;
    } else {
	return None;
    }
}

Atom convert_sel_outer(Window requestor, Atom target, Atom property) {
    if (target == multiple_atom) {
	/*
	 * Support for the MULTIPLE selection type, since it's
	 * specified as required in the ICCCM. Completely
	 * untested, though, because I have no idea of what X
	 * application might implement it for me to test against.
	 */

	int size = SELDELTA;
	Atom actual_type;
	int actual_format, i;
	long nitems, bytes_after, nread;
	unsigned char *data;
	Atom *adata;

	/*
	 * Fetch the requestor's window property giving a list of
	 * selection requests.
	 */
	while (XGetWindowProperty(disp, requestor, property, 0, size,
				  False, AnyPropertyType, &actual_type,
				  &actual_format, &nitems, &bytes_after,
				  (unsigned char **) &data) == Success &&
	       nitems * (actual_format / 8) == size) {
	    XFree(data);
	    size *= 3 / 2;
	}

	if (actual_type != atom_pair_atom || actual_format != 32) {
	    XFree(data);
	    return None;
	}

	adata = (Atom *)data;

	for (i = 0; i+1 < nitems; i += 2) {
	    adata[i+1] = convert_sel_inner(requestor, adata[i], adata[i+1]);
	}

	XChangeProperty (disp, requestor, property,
			 atom_pair_atom, 32, PropModeReplace,
			 data, nitems);

	XFree(data);

	return property;
    } else {
	return convert_sel_inner(requestor, target, property);
    }
}

void run_X(void) {
    XEvent ev, e2;

    while (1) {
	XNextEvent (disp, &ev);
        if (reading) {
            switch (ev.type) {
              case SelectionNotify:
                if (ev.xselection.property != None)
                    do_paste(ev.xselection.requestor,
                             ev.xselection.property, True);
                return;
            }
        } else {
            switch (ev.type) {
              case SelectionClear:
                /* Selection has been cleared by another app. */
                return;
              case SelectionRequest:
                e2.xselection.type = SelectionNotify;
                e2.xselection.requestor = ev.xselectionrequest.requestor;
                e2.xselection.selection = ev.xselectionrequest.selection;
                e2.xselection.target = ev.xselectionrequest.target;
                e2.xselection.time = ev.xselectionrequest.time;
                e2.xselection.property =
		    convert_sel_outer(ev.xselectionrequest.requestor,
				      ev.xselectionrequest.target,
				      ev.xselectionrequest.property);
                XSendEvent (disp, ev.xselectionrequest.requestor,
			    False, 0, &e2);
            }
        }
    }
}

void done_X(void) {
    int i;

    if (ourwin != None)
	XDestroyWindow (disp, ourwin);
    if (disp)
	XCloseDisplay (disp);
}

void do_paste(Window window, Atom property, int Delete) {
    Atom actual_type;
    int actual_format, i;
    long nitems, bytes_after, nread;
    unsigned char *data;

    nread = 0;
    while (XGetWindowProperty(disp, window, property, nread / 4, SELDELTA,
                              Delete, AnyPropertyType, &actual_type,
                              &actual_format, &nitems, &bytes_after,
                              (unsigned char **) &data) == Success) {
	if (nitems > 0) {
	    /*
	     * We expect all returned chunks of data to be
	     * multiples of 4 bytes (because we can only request
	     * the subsequent starting offset in 4-byte
	     * increments). Of course you can store an odd number
	     * of bytes in a selection, so this can't be the case
	     * every time XGetWindowProperty returns; but it
	     * should be the case every time it returns _and there
	     * is more data to come_.
	     *
	     * Hence, whenever XGetWindowProperty returns, we
	     * verify that the size of the data returned _last_
	     * time was divisible by 4.
	     */
	    if ((nread & 3) != 0) {
		error("unexpected data size: %d read (not a multiple"
		      " of 4), but more to come\n", nread);
	    }

	    if (expected_type != (Atom)None && actual_type != expected_type) {
		char *expout = XGetAtomName(disp, expected_type);
		char *gotout = (actual_type == (Atom)None ? "None" :
				XGetAtomName(disp, actual_type));
		error("unexpected data type: expected %s, got %s\n",
		      expout, gotout);
	    }
	    if (expected_format && expected_format != actual_format) {
		error("unexpected data format: expected %d-bit, got %d-bit\n",
		      expected_format, actual_format);
	    }
	}

        if (nitems > 0) {
	    if (mode == TARGETS) {
		assert(actual_format == 32);
		int i;
		for (i = 0; i < nitems; i++) {
		    Atom x = ((Atom *)data)[i];
		    printf("%s\n", XGetAtomName(disp, x));
		}
	    } else if (mode == TIMESTAMP) {
		assert(actual_format == 32);
		Time x = ((Time *)data)[0];
		printf("%lu\n", (unsigned long)x);
	    } else {
		fwrite(data, actual_format / 8, nitems, stdout);
		nread += nitems * actual_format / 8;
	    }
        }
        XFree(data);
        if (nitems == 0)
            break;
    }
}
Commit	Line	Data
9acadc2b	1	/*
	2	* xcopy: quickly pipe text data into, or out of, the primary X
	3	* selection
	4	*/
	5
9acadc2b	6	#include <stdio.h>
	7	#include <stdlib.h>
	8	#include <string.h>
	9	#include <stdarg.h>
	10	#include <math.h>
	11	#include <errno.h>
	12	#include <assert.h>
	13
	14	#include <X11/X.h>
	15	#include <X11/Xlib.h>
	16	#include <X11/Xutil.h>
	17	#include <X11/Xatom.h>
	18
	19	int init_X(void);
	20	void run_X(void);
	21	void done_X(void);
	22	void full_redraw(void);
	23	void do_paste(Window window, Atom property, int Delete);
	24
	25	char pname; / program name */
	26
	27	void error (char *fmt, ...);
	28
	29	/* set from command-line parameters */
	30	char *display = NULL;
3ffcf184	31	enum { STRING, CTEXT, UTF8, TARGETS, TIMESTAMP, CUSTOM } mode = STRING;
5e36d477	32	int use_clipboard = False;
3ffcf184	33	char *custom_seltype = NULL;
acc02b82	34	int fork_when_writing = True;
9acadc2b	35
	36	/* selection data */
	37	char *seltext;
	38	int sellen, selsize;
	39	#define SELDELTA 16384
	40
	41	/* functional parameters */
	42	int reading; /* read instead of writing? */
	43	int convert_to_ctext = True; /* Xmb convert to compound text? */
	44
da0f8522	45	const char usagemsg[] =
da0f8522	46	"usage: xcopy [ -r ] [ -u \| -c ] [ -C ]\n"
3ffcf184	47	"where: -r read X selection and print on stdout\n"
	48	" no -r read stdin and store in X selection\n"
	49	" -u work with UTF8_STRING type selections\n"
	50	" -c work with COMPOUND_TEXT type selections\n"
	51	" -C suppress automatic conversion to COMPOUND_TEXT\n"
	52	" -b read the CLIPBOARD rather than the PRIMARY selection\n"
	53	" -t get the list of targets available to retrieve\n"
	54	" -T get the time stamp of the selection contents\n"
	55	" -a atom get an arbitrary form of the selection data\n"
acc02b82	56	" -F do not fork in write mode\n"
c52f9fb9	57	" also: xcopy --version report version number\n"
	58	" xcopy --help display this help text\n"
	59	" xcopy --licence display the (MIT) licence text\n"
da0f8522	60	;
	61
	62	void usage(void) {
	63	fputs(usagemsg, stdout);
	64	}
	65
	66	const char licencemsg[] =
	67	"xcopy is copyright 2001-2004 Simon Tatham.\n"
	68	"\n"
	69	"Permission is hereby granted, free of charge, to any person\n"
	70	"obtaining a copy of this software and associated documentation files\n"
	71	"(the \"Software\"), to deal in the Software without restriction,\n"
	72	"including without limitation the rights to use, copy, modify, merge,\n"
	73	"publish, distribute, sublicense, and/or sell copies of the Software,\n"
	74	"and to permit persons to whom the Software is furnished to do so,\n"
	75	"subject to the following conditions:\n"
	76	"\n"
	77	"The above copyright notice and this permission notice shall be\n"
	78	"included in all copies or substantial portions of the Software.\n"
	79	"\n"
	80	"THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n"
	81	"EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n"
	82	"MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\n"
	83	"NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\n"
	84	"BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\n"
	85	"ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\n"
	86	"CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n"
	87	"SOFTWARE.\n"
	88	;
	89
	90	void licence(void) {
	91	fputs(licencemsg, stdout);
	92	}
	93
	94	void version(void) {
	95	#define SVN_REV "$Revision$"
	96	char rev[sizeof(SVN_REV)];
	97	char p, q;
	98
	99	strcpy(rev, SVN_REV);
	100
	101	for (p = rev; p && p != ':'; p++);
	102	if (*p) {
	103	p++;
	104	while (p && isspace(p)) p++;
	105	for (q = p; q && q != '$'; q++);
	106	if (q) q = '\0';
	107	printf("xcopy revision %s\n", p);
	108	} else {
	109	printf("xcopy: unknown version\n");
	110	}
	111	}
	112
9acadc2b	113	int main(int ac, char **av) {
	114	int n;
	115	int eventloop;
	116
	117	pname = *av;
	118
	119	/* parse the command line arguments */
3ffcf184	120	while (--ac > 0) {
9acadc2b	121	char p = ++av;
	122
	123	if (!strcmp(p, "-display") \|\| !strcmp(p, "-disp")) {
	124	if (!av[1])
	125	error ("option `%s' expects a parameter", p);
	126	display = *++av, --ac;
	127	} else if (!strcmp(p, "-r")) {
	128	reading = True;
	129	} else if (!strcmp(p, "-u")) {
	130	mode = UTF8;
	131	} else if (!strcmp(p, "-c")) {
	132	mode = CTEXT;
	133	} else if (!strcmp(p, "-C")) {
	134	convert_to_ctext = False;
5e36d477	135	} else if (!strcmp(p, "-b")) {
5e36d477	136	use_clipboard = True;
3ffcf184	137	} else if (!strcmp(p, "-t")) {
	138	mode = TARGETS;
	139	} else if (!strcmp(p, "-T")) {
	140	mode = TIMESTAMP;
	141	} else if (!strcmp(p, "-a")) {
	142	if (--ac > 0)
	143	custom_seltype = *++av;
	144	else
	145	error ("expected an argument to `-a'");
	146	mode = CUSTOM;
acc02b82	147	} else if (!strcmp(p, "-F")) {
acc02b82	148	fork_when_writing = False;
da0f8522	149	} else if (!strcmp(p, "--help")) {
	150	usage();
	151	return 0;
	152	} else if (!strcmp(p, "--version")) {
	153	version();
	154	return 0;
	155	} else if (!strcmp(p, "--licence") \|\| !strcmp(p, "--license")) {
	156	licence();
	157	return 0;
9acadc2b	158	} else if (*p=='-') {
	159	error ("unrecognised option `%s'", p);
	160	} else {
	161	error ("no parameters required");
	162	}
	163	}
	164
	165	if (!reading) {
3ffcf184	166	if (mode == TARGETS \|\| mode == TIMESTAMP \|\| mode == CUSTOM) {
	167	error ("%s not supported in writing mode; use -r",
	168	(mode == TARGETS ? "-t" :
	169	mode == TIMESTAMP ? "-T" :
	170	/* mode == CUSTOM ? */ "-a"));
	171	}
	172	}
	173
	174	if (!reading) {
9acadc2b	175	seltext = malloc(SELDELTA);
	176	if (!seltext)
	177	error ("out of memory");
	178	selsize = SELDELTA;
	179	sellen = 0;
	180	do {
	181	n = fread(seltext+sellen, 1, selsize-sellen, stdin);
	182	sellen += n;
	183	if (sellen >= selsize) {
	184	seltext = realloc(seltext, selsize += SELDELTA);
	185	if (!seltext)
	186	error ("out of memory");
	187	}
	188	} while (n > 0);
	189	if (sellen == selsize) {
	190	seltext = realloc(seltext, selsize += SELDELTA);
	191	if (!seltext)
	192	error ("out of memory");
	193	}
	194	seltext[sellen] = '\0';
	195	}
	196
	197	eventloop = init_X();
acc02b82	198	if (!reading && fork_when_writing) {
9acadc2b	199	/*
	200	* If we are writing the selection, we must go into the
	201	* background now.
	202	*/
	203	int pid = fork();
	204	if (pid < 0) {
	205	error("unable to fork: %s", strerror(errno));
	206	} else if (pid > 0) {
	207	/*
	208	* we are the parent; just exit
	209	*/
	210	return 0;
	211	}
	212	/*
	213	* we are the child
	214	*/
	215	close(0);
	216	close(1);
	217	close(2);
	218	chdir("/");
	219	}
	220	if (eventloop)
	221	run_X();
	222	done_X();
	223	return 0;
	224	}
	225
	226	/* handle errors */
	227
	228	void error (char *fmt, ...) {
	229	va_list ap;
	230	char errbuf[200];
	231
	232	done_X();
	233	va_start (ap, fmt);
	234	vsprintf (errbuf, fmt, ap);
	235	va_end (ap);
	236	fprintf (stderr, "%s: %s\n", pname, errbuf);
	237	exit (1);
	238	}
	239
	240	/* begin the X interface */
	241
	242	char *lcasename = "xcopy";
	243	char *ucasename = "XCopy";
	244
	245	Display *disp = NULL;
	246	Window ourwin = None;
acc02b82	247	Atom compound_text_atom, targets_atom, timestamp_atom, atom_atom, integer_atom;
e1c1021f	248	Atom multiple_atom, atom_pair_atom;
9acadc2b	249	int screen, wwidth, wheight;
	250
	251	Atom strtype = XA_STRING;
5e36d477	252	Atom sel_atom = XA_PRIMARY;
3ffcf184	253	Atom expected_type = (Atom)None;
3ffcf184	254	int expected_format = 8;
9acadc2b	255
	256	/*
	257	* Returns TRUE if we need to enter an event loop, FALSE otherwise.
	258	*/
	259	int init_X(void) {
	260	Window root;
	261	int x = 0, y = 0, width = 512, height = 128;
	262	int i, got = 0;
	263	XWMHints wm_hints;
	264	XSizeHints size_hints;
	265	XClassHint class_hints;
	266	XTextProperty textprop;
	267	XGCValues gcv;
	268
	269	/* open the X display */
	270	disp = XOpenDisplay (display);
	271	if (!disp)
	272	error ("unable to open display");
	273
3ffcf184	274	targets_atom = XInternAtom(disp, "TARGETS", False);
acc02b82	275	timestamp_atom = XInternAtom(disp, "TIMESTAMP", False);
acc02b82	276	atom_atom = XInternAtom(disp, "ATOM", False);
e1c1021f	277	atom_pair_atom = XInternAtom(disp, "ATOM_PAIR", False);
e1c1021f	278	multiple_atom = XInternAtom(disp, "MULTIPLE", False);
acc02b82	279	integer_atom = XInternAtom(disp, "INTEGER", False);
9acadc2b	280	if (mode == UTF8) {
9acadc2b	281	strtype = XInternAtom(disp, "UTF8_STRING", False);
9acadc2b	282	} else if (mode == CTEXT) {
9acadc2b	283	strtype = XInternAtom(disp, "COMPOUND_TEXT", False);
3ffcf184	284	} else if (mode == TARGETS) {
3ffcf184	285	strtype = targets_atom;
acc02b82	286	expected_type = atom_atom;
3ffcf184	287	expected_format = 32;
3ffcf184	288	} else if (mode == TIMESTAMP) {
acc02b82	289	strtype = timestamp_atom;
acc02b82	290	expected_type = integer_atom;
3ffcf184	291	expected_format = 32;
3ffcf184	292	} else if (mode == CUSTOM) {
acc02b82	293	strtype = XInternAtom(disp, custom_seltype, True);
	294	if (!strtype)
	295	error ("atom '%s' does not exist on the server", custom_seltype);
3ffcf184	296	expected_format = 0;
9acadc2b	297	}
5e36d477	298	if (use_clipboard) {
5e36d477	299	sel_atom = XInternAtom(disp, "CLIPBOARD", False);
5e36d477	300	}
9acadc2b	301
	302	/* get the screen and root-window */
	303	screen = DefaultScreen (disp);
	304	root = RootWindow (disp, screen);
	305
	306	x = y = 0;
	307	width = height = 10; /* doesn't really matter */
	308
	309	/* actually create the window */
	310	ourwin = XCreateSimpleWindow (disp, root, x, y, width, height,0,
	311	BlackPixel(disp, screen),
	312	WhitePixel(disp, screen));
	313
	314	/* resource class name */
	315	class_hints.res_name = lcasename;
	316	class_hints.res_class = ucasename;
	317	XSetClassHint (disp, ourwin, &class_hints);
	318
	319	/* do selection fiddling */
	320	if (reading) {
	321	/*
	322	* We are reading the selection, so we must FIXME.
	323	*/
5e36d477	324	if (XGetSelectionOwner(disp, sel_atom) == None) {
9acadc2b	325	/* No primary selection, so use the cut buffer. */
3ffcf184	326	if (strtype == XA_STRING)
3ffcf184	327	do_paste(DefaultRootWindow(disp), XA_CUT_BUFFER0, False);
9acadc2b	328	return False;
	329	} else {
	330	Atom sel_property = XInternAtom(disp, "VT_SELECTION", False);
5e36d477	331	XConvertSelection(disp, sel_atom, strtype,
9acadc2b	332	sel_property, ourwin, CurrentTime);
	333	return True;
	334	}
	335	} else {
	336	/*
	337	* We are writing to the selection, so we establish
	338	* ourselves as selection owner. Also place the data in
	339	* CUT_BUFFER0, if it isn't of an exotic type (cut buffers
	340	* can only take ordinary string data, it turns out).
	341	*/
5e36d477	342	XSetSelectionOwner (disp, sel_atom, ourwin, CurrentTime);
5e36d477	343	if (XGetSelectionOwner (disp, sel_atom) != ourwin)
9acadc2b	344	error ("unable to obtain primary X selection\n");
	345	compound_text_atom = XInternAtom(disp, "COMPOUND_TEXT", False);
	346	if (strtype == XA_STRING) {
	347	/*
	348	* ICCCM-required cut buffer initialisation.
	349	*/
	350	XChangeProperty(disp, root, XA_CUT_BUFFER0,
	351	XA_STRING, 8, PropModeAppend, "", 0);
	352	XChangeProperty(disp, root, XA_CUT_BUFFER1,
	353	XA_STRING, 8, PropModeAppend, "", 0);
	354	XChangeProperty(disp, root, XA_CUT_BUFFER2,
	355	XA_STRING, 8, PropModeAppend, "", 0);
	356	XChangeProperty(disp, root, XA_CUT_BUFFER3,
	357	XA_STRING, 8, PropModeAppend, "", 0);
	358	XChangeProperty(disp, root, XA_CUT_BUFFER4,
	359	XA_STRING, 8, PropModeAppend, "", 0);
	360	XChangeProperty(disp, root, XA_CUT_BUFFER5,
	361	XA_STRING, 8, PropModeAppend, "", 0);
	362	XChangeProperty(disp, root, XA_CUT_BUFFER6,
	363	XA_STRING, 8, PropModeAppend, "", 0);
	364	XChangeProperty(disp, root, XA_CUT_BUFFER7,
	365	XA_STRING, 8, PropModeAppend, "", 0);
	366	/*
	367	* Rotate the cut buffers and add our text in CUT_BUFFER0.
	368	*/
	369	XRotateBuffers(disp, 1);
	370	XStoreBytes(disp, seltext, sellen);
	371	}
	372	return True;
	373	}
	374	}
	375
e1c1021f	376	Atom convert_sel_inner(Window requestor, Atom target, Atom property) {
	377	if (target == strtype) {
	378	XChangeProperty (disp, requestor, property, strtype,
	379	8, PropModeReplace, seltext, sellen);
	380	return property;
	381	} else if (target == compound_text_atom && convert_to_ctext) {
	382	XTextProperty tp;
	383	XmbTextListToTextProperty (disp, &seltext, 1,
	384	XCompoundTextStyle, &tp);
	385	XChangeProperty (disp, requestor, property, target,
	386	tp.format, PropModeReplace,
	387	tp.value, tp.nitems);
	388	return property;
	389	} else if (target == targets_atom) {
	390	Atom targets[16];
	391	int len = 0;
	392	targets[len++] = timestamp_atom;
	393	targets[len++] = targets_atom;
	394	targets[len++] = multiple_atom;
	395	targets[len++] = strtype;
	396	if (strtype != compound_text_atom && convert_to_ctext)
	397	targets[len++] = compound_text_atom;
	398	XChangeProperty (disp, requestor, property,
	399	atom_atom, 32, PropModeReplace,
	400	(unsigned char *)targets, len);
	401	return property;
	402	} else if (target == timestamp_atom) {
	403	Time rettime = CurrentTime;
	404	XChangeProperty (disp, requestor, property,
	405	integer_atom, 32, PropModeReplace,
	406	(unsigned char *)&rettime, 1);
	407	return property;
	408	} else {
	409	return None;
	410	}
	411	}
	412
	413	Atom convert_sel_outer(Window requestor, Atom target, Atom property) {
	414	if (target == multiple_atom) {
	415	/*
	416	* Support for the MULTIPLE selection type, since it's
	417	* specified as required in the ICCCM. Completely
	418	* untested, though, because I have no idea of what X
	419	* application might implement it for me to test against.
	420	*/
	421
	422	int size = SELDELTA;
	423	Atom actual_type;
	424	int actual_format, i;
	425	long nitems, bytes_after, nread;
	426	unsigned char *data;
	427	Atom *adata;
	428
	429	/*
	430	* Fetch the requestor's window property giving a list of
	431	* selection requests.
	432	*/
	433	while (XGetWindowProperty(disp, requestor, property, 0, size,
	434	False, AnyPropertyType, &actual_type,
	435	&actual_format, &nitems, &bytes_after,
	436	(unsigned char **) &data) == Success &&
	437	nitems * (actual_format / 8) == size) {
	438	XFree(data);
	439	size *= 3 / 2;
440	}
441
442	if (actual_type != atom_pair_atom \|\| actual_format != 32) {
443	XFree(data);
444	return None;
445	}
446
447	adata = (Atom *)data;
448
449	for (i = 0; i+1 < nitems; i += 2) {
450	adata[i+1] = convert_sel_inner(requestor, adata[i], adata[i+1]);
451	}
452
453	XChangeProperty (disp, requestor, property,
454	atom_pair_atom, 32, PropModeReplace,
455	data, nitems);
456
457	XFree(data);
458
459	return property;
460	} else {
461	return convert_sel_inner(requestor, target, property);
462	}
463	}
464
9acadc2b	465	void run_X(void) {
	466	XEvent ev, e2;
	467
	468	while (1) {
	469	XNextEvent (disp, &ev);
	470	if (reading) {
	471	switch (ev.type) {
	472	case SelectionNotify:
	473	if (ev.xselection.property != None)
	474	do_paste(ev.xselection.requestor,
	475	ev.xselection.property, True);
	476	return;
	477	}
	478	} else {
	479	switch (ev.type) {
	480	case SelectionClear:
	481	/* Selection has been cleared by another app. */
	482	return;
	483	case SelectionRequest:
	484	e2.xselection.type = SelectionNotify;
	485	e2.xselection.requestor = ev.xselectionrequest.requestor;
	486	e2.xselection.selection = ev.xselectionrequest.selection;
	487	e2.xselection.target = ev.xselectionrequest.target;
	488	e2.xselection.time = ev.xselectionrequest.time;
e1c1021f	489	e2.xselection.property =
	490	convert_sel_outer(ev.xselectionrequest.requestor,
	491	ev.xselectionrequest.target,
	492	ev.xselectionrequest.property);
	493	XSendEvent (disp, ev.xselectionrequest.requestor,
	494	False, 0, &e2);
9acadc2b	495	}
	496	}
	497	}
	498	}
	499
	500	void done_X(void) {
	501	int i;
	502
	503	if (ourwin != None)
	504	XDestroyWindow (disp, ourwin);
	505	if (disp)
	506	XCloseDisplay (disp);
	507	}
	508
	509	void do_paste(Window window, Atom property, int Delete) {
	510	Atom actual_type;
	511	int actual_format, i;
	512	long nitems, bytes_after, nread;
	513	unsigned char *data;
	514
	515	nread = 0;
	516	while (XGetWindowProperty(disp, window, property, nread / 4, SELDELTA,
	517	Delete, AnyPropertyType, &actual_type,
	518	&actual_format, &nitems, &bytes_after,
	519	(unsigned char **) &data) == Success) {
3ffcf184	520	if (nitems > 0) {
5340832d	521	/*
	522	* We expect all returned chunks of data to be
	523	* multiples of 4 bytes (because we can only request
	524	* the subsequent starting offset in 4-byte
	525	* increments). Of course you can store an odd number
	526	* of bytes in a selection, so this can't be the case
	527	* every time XGetWindowProperty returns; but it
	528	* should be the case every time it returns _and there
	529	* is more data to come_.
	530	*
	531	* Hence, whenever XGetWindowProperty returns, we
	532	* verify that the size of the data returned _last_
	533	* time was divisible by 4.
	534	*/
	535	if ((nread & 3) != 0) {
	536	error("unexpected data size: %d read (not a multiple"
	537	" of 4), but more to come\n", nread);
	538	}
	539
3ffcf184	540	if (expected_type != (Atom)None && actual_type != expected_type) {
	541	char *expout = XGetAtomName(disp, expected_type);
	542	char *gotout = (actual_type == (Atom)None ? "None" :
	543	XGetAtomName(disp, actual_type));
	544	error("unexpected data type: expected %s, got %s\n",
	545	expout, gotout);
	546	}
	547	if (expected_format && expected_format != actual_format) {
	548	error("unexpected data format: expected %d-bit, got %d-bit\n",
	549	expected_format, actual_format);
	550	}
	551	}
	552
	553	if (nitems > 0) {
	554	if (mode == TARGETS) {
	555	assert(actual_format == 32);
	556	int i;
	557	for (i = 0; i < nitems; i++) {
	558	Atom x = ((Atom *)data)[i];
	559	printf("%s\n", XGetAtomName(disp, x));
	560	}
	561	} else if (mode == TIMESTAMP) {
	562	assert(actual_format == 32);
	563	Time x = ((Time *)data)[0];
	564	printf("%lu\n", (unsigned long)x);
	565	} else {
	566	fwrite(data, actual_format / 8, nitems, stdout);
	567	nread += nitems * actual_format / 8;
	568	}
9acadc2b	569	}
9acadc2b	570	XFree(data);
3ffcf184	571	if (nitems == 0)
9acadc2b	572	break;
	573	}
	574	}