X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=citadel%2Futils%2Fsendcommand.c;h=6146dbb654f7a8ae845cc9012f96dce5f84a3238;hb=4daf814a186671f0773b926fbd5bde4f27665e1f;hp=71764bcbbbce69e2a84edf081ca5860dd52b15e7;hpb=57b37d4ed168b176d594bc149e5d16a1b9f0517a;p=citadel.git

diff --git a/citadel/utils/sendcommand.c b/citadel/utils/sendcommand.c
index 71764bcbb..6146dbb65 100644
--- a/citadel/utils/sendcommand.c
+++ b/citadel/utils/sendcommand.c
@@ -12,8 +12,7 @@
  * GNU General Public License for more details.
  */
 
-#include "ctdl_module.h"
-
+#include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <sys/types.h>
@@ -22,264 +21,295 @@
 #include <fcntl.h>
 #include <stdio.h>
 #include <ctype.h>
-
-#if TIME_WITH_SYS_TIME
-# include <sys/time.h>
-# include <time.h>
-#else
-# if HAVE_SYS_TIME_H
-#  include <sys/time.h>
-# else
-#  include <time.h>
-# endif
-#endif
-
 #include <signal.h>
 #include <errno.h>
 #include <limits.h>
-#include <libcitadel.h>
+#include <sys/socket.h>
+#include <sys/un.h>
 #include "citadel.h"
-#include "citadel_ipc.h"
-#include "server.h"
-#include "config.h"
+#include "include/citadel_dirs.h"
+#include <libcitadel.h>
+
+
+int serv_sock = (-1);
+
+
+int uds_connectsock(char *sockpath)
+{
+	int s;
+	struct sockaddr_un addr;
+
+	memset(&addr, 0, sizeof(addr));
+	addr.sun_family = AF_UNIX;
+	strncpy(addr.sun_path, sockpath, sizeof addr.sun_path);
+
+	s = socket(AF_UNIX, SOCK_STREAM, 0);
+	if (s < 0) {
+		fprintf(stderr, "sendcommand: Can't create socket: %s\n", strerror(errno));
+		exit(3);
+	}
+
+	if (connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
+		fprintf(stderr, "sendcommand: can't connect: %s\n", strerror(errno));
+		close(s);
+		exit(3);
+	}
+
+	return s;
+}
 
-static CtdlIPC *ipc = NULL;
 
 /*
- * Why both cleanup() and nq_cleanup() ?  Notice the alarm() call in
- * cleanup() .  If for some reason sendcommand hangs waiting for the server
- * to clean up, the alarm clock goes off and the program exits anyway.
- * The cleanup() routine makes a check to ensure it's not reentering, in
- * case the ipc module looped it somehow.
+ * input binary data from socket
  */
-void nq_cleanup(int e)
+void serv_read(char *buf, int bytes)
 {
-	if (e == SIGALRM)
-		fprintf(stderr, "\nWatch dog time out.\n");
-	exit(e);
+	int len, rlen;
+
+	len = 0;
+	while (len < bytes) {
+		rlen = read(serv_sock, &buf[len], bytes - len);
+		if (rlen < 1) {
+			return;
+		}
+		len = len + rlen;
+	}
 }
 
+
 /*
  * send binary to server
  */
-void serv_write(CtdlIPC *ipc, const char *buf, unsigned int nbytes)
+void serv_write(char *buf, int nbytes)
 {
-	unsigned int bytes_written = 0;
-	int retval = 0;
-
+	int bytes_written = 0;
+	int retval;
 	while (bytes_written < nbytes) {
-		retval = write(ipc->sock, &buf[bytes_written],
-			       nbytes - bytes_written);
+		retval = write(serv_sock, &buf[bytes_written], nbytes - bytes_written);
 		if (retval < 1) {
-			connection_died(ipc, 0);
 			return;
 		}
-		bytes_written += retval;
+		bytes_written = bytes_written + retval;
 	}
 }
 
 
-void cleanup(int e)
-{
-	static int nested = 0;
-
-	alarm(30);
-	signal(SIGALRM, nq_cleanup);
-	if ((ipc != NULL) && 
-	    (ipc->sock > 0))
-		serv_write(ipc, "\n", 1);
-	if ((nested++ < 1) &&
-	    (ipc != NULL) &&
-	    (ipc->sock > 0))
-		CtdlIPCQuit(ipc);
-	nq_cleanup(e);
-}
 
 /*
- * This is implemented as a function rather than as a macro because the
- * client-side IPC modules expect logoff() to be defined.  They call logoff()
- * when a problem connecting or staying connected to the server occurs.
+ * input string from socket - implemented in terms of serv_read()
  */
-void logoff(int e)
+void serv_gets(char *buf)
 {
-	cleanup(e);
-}
+	int i;
 
-/*
- * Connect sendcommand to the Citadel server running on this computer.
- */
-void np_attach_to_server(char *host, char *port)
-{
-	char buf[SIZ];
-	char hostbuf[256], portbuf[256];
-	char *args[] =
-	{"sendcommand", NULL};
-	int r;
-
-	fprintf(stderr, "Attaching to server...\n");
-	strcpy(hostbuf, host);
-	strcpy(portbuf, port);
-	ipc = CtdlIPC_new(1, args, hostbuf, portbuf);
-	if (!ipc) {
-		fprintf(stderr, "Can't connect: %s\n", strerror(errno));
-		exit(3);
+	/* Read one character at a time.
+	 */
+	for (i = 0;; i++) {
+		serv_read(&buf[i], 1);
+		if (buf[i] == '\n' || i == (SIZ-1))
+			break;
 	}
-	CtdlIPC_chat_recv(ipc, buf);
-	fprintf(stderr, "%s\n", &buf[4]);
-	snprintf(buf, sizeof buf, "IPGM %d", config.c_ipgm_secret);
-	r = CtdlIPCInternalProgram(ipc, config.c_ipgm_secret, buf);
-	fprintf(stderr, "%s\n", buf);
-	if (r / 100 != 2) {
-		cleanup(2);
+
+	/* If we got a long line, discard characters until the newline.
+	 */
+	if (i == (SIZ-1)) {
+		while (buf[i] != '\n') {
+			serv_read(&buf[i], 1);
+		}
 	}
+
+	/* Strip all trailing nonprintables (crlf)
+	 */
+	buf[i] = 0;
 }
 
 
-void sendcommand_die(void) {
-	exit(0);
+/*
+ * send line to server - implemented in terms of serv_write()
+ */
+void serv_puts(char *buf)
+{
+	serv_write(buf, strlen(buf));
+	serv_write("\n", 1);
 }
 
 
 
+
+/*
+ * Main loop.  Do things and have fun.
+ */
 int main(int argc, char **argv)
 {
 	int a;
-	char cmd[SIZ];
-	char buf[SIZ];
 	int watchdog = 60;
-
+	char buf[SIZ];
+	int xfermode = 0;
 	int relh=0;
 	int home=0;
 	char relhome[PATH_MAX]="";
 	char ctdldir[PATH_MAX]=CTDLDIR;
-	fd_set read_fd;
-	struct timeval tv;
-	int ret;
-	int server_shutting_down = 0;
-	
-	strcpy(ctdl_home_directory, DEFAULT_PORT);
 
-	strcpy(cmd, "");
-	/*
-	 * Change directories if specified
-	 */
-	for (a = 1; a < argc; ++a) {
-		if (!strncmp(argv[a], "-h", 2)) {
-			relh=argv[a][2]!='/';
-			if (!relh) safestrncpy(ctdl_home_directory, &argv[a][2], sizeof ctdl_home_directory);
-			else {
-				safestrncpy(relhome, &argv[a][2], sizeof relhome);
+	/* Parse command line */
+	while ((a = getopt(argc, argv, "h:w:")) != EOF) {
+		switch (a) {
+		case 'h':
+			relh=optarg[0]!='/';
+			if (!relh) {
+				strncpy(ctdl_home_directory, optarg, sizeof ctdl_home_directory);
+			} else {
+				strncpy(relhome, optarg, sizeof relhome);
 			}
-			home=1;
-		} else if (!strncmp(argv[a], "-w", 2)) {
-			watchdog = atoi(&argv[a][2]);
-			if (watchdog<1)
-				watchdog=1;
-		} else {
-			if (!IsEmptyStr(cmd)) {
-				strcat(cmd, " ");
-			}
-			strcat(cmd, argv[a]);
+			home = 1;
+			break;
+		case 'w':
+			watchdog = atoi(optarg);
+			break;
+		default:
+			fprintf(stderr, "sendcommand: usage: sendcommand [-h server_dir] [-w watchdog_timeout]\n");
+			return(1);
 		}
 	}
 
 	calc_dirs_n_files(relh, home, relhome, ctdldir, 0);
-	get_config();
-
-	signal(SIGINT, cleanup);
-	signal(SIGQUIT, cleanup);
-	signal(SIGHUP, cleanup);
-	signal(SIGTERM, cleanup);
 
-	fprintf(stderr, "sendcommand: started (pid=%d) "
-			"running in %s\n",
-			(int) getpid(),
-			ctdl_home_directory);
+	fprintf(stderr, "sendcommand: started (pid=%d) connecting to Citadel server at %s\n",
+		(int) getpid(),
+		file_citadel_admin_socket
+	);
 	fflush(stderr);
 
-	alarm(watchdog);
-	signal(SIGALRM, nq_cleanup); /* Set up a watchdog type timer in case we hang */
-	
-	np_attach_to_server(UDS, ctdl_home_directory);
-	fflush(stderr);
-	setIPCDeathHook(sendcommand_die);
+//	alarm(watchdog);
+	serv_sock = uds_connectsock(file_citadel_admin_socket);
 
-	fprintf(stderr, "%s\n", cmd);
-	CtdlIPC_chat_send(ipc, cmd);
-	CtdlIPC_chat_recv(ipc, buf);
+	serv_gets(buf);
 	fprintf(stderr, "%s\n", buf);
 
-	tv.tv_sec = 0;
-	tv.tv_usec = 1000;
-
-	if (!strncasecmp(&buf[1], "31", 2)) {
-		server_shutting_down = 1;
+	strcpy(buf, "");
+	for (a=optind; a<argc; ++a) {
+		if (a != optind) {
+			strcat(buf, " ");
+		}
+		strcat(buf, argv[a]);
 	}
 
-	if (buf[0] == '1') {
-		while (CtdlIPC_chat_recv(ipc, buf), strcmp(buf, "000")) {
-			printf("%s\n", buf);
-			alarm(watchdog); /* Kick the watchdog timer */
-		}
-	} else if (buf[0] == '4') {
-		do {
-			if (fgets(buf, sizeof buf, stdin) == NULL)
-				strcpy(buf, "000");
-			if (!IsEmptyStr(buf))
-				if (buf[strlen(buf) - 1] == '\n')
-					buf[strlen(buf) - 1] = 0;
-			if (!IsEmptyStr(buf))
-				if (buf[strlen(buf) - 1] == '\r')
-					buf[strlen(buf) - 1] = 0;
-			if (strcmp(buf, "000"))
-				CtdlIPC_chat_send(ipc, buf);
-			
-			FD_ZERO(&read_fd);
-			FD_SET(ipc->sock, &read_fd);
-			ret = select(ipc->sock+1, &read_fd, NULL, NULL,  &tv);
-			if (ret == -1) {
-				if (!(errno == EINTR || errno == EAGAIN))
-					fprintf(stderr, "select() failed: %s", strerror(errno));
-				return(1);
-			}
+	fprintf(stderr, "%s\n", buf);
+	serv_puts(buf);
+	serv_gets(buf);
+	fprintf(stderr, "%s\n", buf);
+
+	xfermode = buf[0];
+
+	if ((xfermode == '4') || (xfermode == '8')) {		/* send text */
+		IOBuffer IOB;
+		FDIOBuffer FDIO;
+		const char *ErrStr;
 
-			if (ret != 0) {
-				size_t n;
-				char rbuf[SIZ];
+		memset(&IOB, 0, sizeof(0));
+		IOB.Buf = NewStrBufPlain(NULL, SIZ);
+		IOB.fd = serv_sock;
+		FDIOBufferInit(&FDIO, &IOB, fileno(stdin), -1);
 
-				rbuf[0] = '\0';
-				n = read(ipc->sock, rbuf, SIZ);
-				if (n>0) {
-					rbuf[n]='\0';
-					fprintf(stderr, "%s", rbuf);
-					fflush (stdout);
+		while (FileSendChunked(&FDIO, &ErrStr));
+			alarm(watchdog);			/* reset the watchdog timer */
+		FDIOBufferDelete(&FDIO);
+		FreeStrBuf(&IOB.Buf);
+		serv_puts("000");
+	}
+
+	if ((xfermode == '1') || (xfermode == '8')) {		/* receive text */
+		IOBuffer IOB;
+		StrBuf *Line, *OutBuf;
+		int Finished = 0;
+
+		memset(&IOB, 0, sizeof(IOB));
+		IOB.Buf = NewStrBufPlain(NULL, SIZ);
+		IOB.fd = serv_sock;
+		Line = NewStrBufPlain(NULL, SIZ);
+		OutBuf = NewStrBufPlain(NULL, SIZ * 10);
+
+		while (!Finished && (StrBuf_read_one_chunk_callback (serv_sock, 0, &IOB) >= 0))
+		{
+			eReadState State;
+
+			State = eReadSuccess;
+			while (!Finished && (State == eReadSuccess))
+			{
+				if (IOBufferStrLength(&IOB) == 0)
+				{
+					State = eMustReadMore;
+					break;
+				}
+				State = StrBufChunkSipLine(Line, &IOB);
+				switch (State)
+				{
+				case eReadSuccess:
+					if (!strcmp(ChrPtr(Line), "000"))
+					{
+						Finished = 1;
+						break;
+					}
+					StrBufAppendBuf(OutBuf, Line, 0);
+					StrBufAppendBufPlain(OutBuf, HKEY("\n"), 0);
+//					alarm(watchdog);			/* reset the watchdog timer */
+					break;
+				case eBufferNotEmpty:
+					break;
+				case eMustReadMore:
+					continue;
+				case eReadFail:
+					fprintf(stderr, "WTF? Exit!\n");
+					exit(-1);
+					break;
+				}
+				if (StrLength(OutBuf) > 5*SIZ)
+				{
+					fwrite(ChrPtr(OutBuf), 1, StrLength(OutBuf), stdout);
+					FlushStrBuf(OutBuf);
 				}
 			}
-			alarm(watchdog); /* Kick the watchdog timer */
-		} while (strcmp(buf, "000"));
-		CtdlIPC_chat_send(ipc, "\n");
-		CtdlIPC_chat_send(ipc, "000");
+		}
+		if (StrLength(OutBuf) > 0)
+		{
+			fwrite(ChrPtr(OutBuf), 1, StrLength(OutBuf), stdout);
+		}
+		FreeStrBuf(&Line);
+		FreeStrBuf(&OutBuf);
+		FreeStrBuf(&IOB.Buf);
 	}
-	alarm(0);	/* Shutdown the watchdog timer */
-	fprintf(stderr, "sendcommand: processing ended.\n");
-
-	/* Clean up and log off ... unless the server indicated that the command
-	 * we sent is shutting it down, in which case we want to just cut the
-	 * connection and exit.
-	 */
-	if (server_shutting_down) {
-		nq_cleanup(0);
+	
+	if (xfermode == '6') {					/* receive binary */
+		size_t len = atoi(&buf[4]);
+		size_t bytes_remaining = len;
+
+		while (bytes_remaining > 0) {
+			size_t this_block = bytes_remaining;
+			if (this_block > SIZ) this_block = SIZ;
+			serv_read(buf, this_block);
+			fwrite(buf, this_block, 1, stdout);
+			bytes_remaining -= this_block;
+		}
 	}
-	else {
-		cleanup(0);
+
+	close(serv_sock);
+	alarm(0);						/* cancel the watchdog timer */
+	fprintf(stderr, "sendcommand: processing ended.\n");
+	if (xfermode == '5') {
+		return(1);
 	}
-	return 0;
+	return(0);
 }
 
-/*
- * Stub function
- */
-void stty_ctdl(int cmd) {
-}
+
+
+
+
+
+
+
+
+
+
+