aboutsummaryrefslogtreecommitdiffstats
path: root/contrib/cvs/src/client.c
diff options
context:
space:
mode:
authorPeter Wemm <peter@FreeBSD.org>1997-05-15 22:46:24 +0000
committerPeter Wemm <peter@FreeBSD.org>1997-05-15 22:46:24 +0000
commit4a59246031483629d4bbbb326c510f30e82ba86b (patch)
tree3b2f0092fa216d9f61059ba94b7f10b5bacf9496 /contrib/cvs/src/client.c
parent18576028af9c8455e19c9f51d94b87e08d1e6bd7 (diff)
downloadsrc-4a59246031483629d4bbbb326c510f30e82ba86b.tar.gz
src-4a59246031483629d4bbbb326c510f30e82ba86b.zip
Import of cvs-1.9.9-970515 onto vendor branch.
Obtained from: cyclic.com
Notes
Notes: svn path=/vendor/cvs/dist/; revision=25839
Diffstat (limited to 'contrib/cvs/src/client.c')
-rw-r--r--contrib/cvs/src/client.c3028
1 files changed, 1783 insertions, 1245 deletions
diff --git a/contrib/cvs/src/client.c b/contrib/cvs/src/client.c
index c0557ce6feee..49f7ac8af0e3 100644
--- a/contrib/cvs/src/client.c
+++ b/contrib/cvs/src/client.c
@@ -4,15 +4,17 @@
#include "config.h"
#endif /* HAVE_CONFIG_H */
+#include <assert.h>
#include "cvs.h"
#include "getline.h"
#include "edit.h"
+#include "buffer.h"
#ifdef CLIENT_SUPPORT
#include "md5.h"
-#if defined(AUTH_CLIENT_SUPPORT) || HAVE_KERBEROS || USE_DIRECT_TCP
+#if defined(AUTH_CLIENT_SUPPORT) || HAVE_KERBEROS || defined(SOCK_ERRNO) || defined(SOCK_STRERROR)
# ifdef HAVE_WINSOCK_H
# include <winsock.h>
# else /* No winsock.h */
@@ -20,13 +22,32 @@
# include <netinet/in.h>
# include <netdb.h>
# endif /* No winsock.h */
-#endif /* defined(AUTH_CLIENT_SUPPORT) || HAVE_KERBEROS || USE_DIRECT_TCP */
+#endif
-#ifdef AUTH_CLIENT_SUPPORT
-char *get_cvs_password PROTO((char *user, char *host, char *cvsrooot));
-#endif /* AUTH_CLIENT_SUPPORT */
+/* If SOCK_ERRNO is defined, then send()/recv() and other socket calls
+ do not set errno, but that this macro should be used to obtain an
+ error code. This probably doesn't make sense unless
+ NO_SOCKET_TO_FD is also defined. */
+#ifndef SOCK_ERRNO
+#define SOCK_ERRNO errno
+#endif
-#if HAVE_KERBEROS || USE_DIRECT_TCP
+/* If SOCK_STRERROR is defined, then the error codes returned by
+ socket operations are not known to strerror, and this macro must be
+ used instead to convert those error codes to strings. */
+#ifndef SOCK_STRERROR
+# define SOCK_STRERROR strerror
+
+# if STDC_HEADERS
+# include <string.h>
+# endif
+
+# ifndef strerror
+extern char *strerror ();
+# endif
+#endif /* ! SOCK_STRERROR */
+
+#if HAVE_KERBEROS
#define CVS_PORT 1999
#if HAVE_KERBEROS
@@ -36,9 +57,14 @@ extern char *krb_realmofhost ();
#ifndef HAVE_KRB_GET_ERR_TEXT
#define krb_get_err_text(status) krb_err_txt[status]
#endif /* HAVE_KRB_GET_ERR_TEXT */
+
+/* Information we need if we are going to use Kerberos encryption. */
+static C_Block kblock;
+static Key_schedule sched;
+
#endif /* HAVE_KERBEROS */
-#endif /* HAVE_KERBEROS || USE_DIRECT_TCP */
+#endif /* HAVE_KERBEROS */
static void add_prune_candidate PROTO((char *));
@@ -70,6 +96,7 @@ static void handle_copy_file PROTO((char *, int));
static void handle_updated PROTO((char *, int));
static void handle_merged PROTO((char *, int));
static void handle_patched PROTO((char *, int));
+static void handle_rcs_diff PROTO((char *, int));
static void handle_removed PROTO((char *, int));
static void handle_remove_entry PROTO((char *, int));
static void handle_set_static_directory PROTO((char *, int));
@@ -81,8 +108,10 @@ static void handle_set_update_prog PROTO((char *, int));
static void handle_module_expansion PROTO((char *, int));
static void handle_m PROTO((char *, int));
static void handle_e PROTO((char *, int));
+static void handle_f PROTO((char *, int));
static void handle_notified PROTO((char *, int));
+static void buf_memory_error PROTO((struct buffer *));
static size_t try_read_from_server PROTO ((char *, size_t));
#endif /* CLIENT_SUPPORT */
@@ -102,29 +131,29 @@ mode_to_string (mode)
mode_t mode;
#endif /* __STDC__ */
{
- char buf[18], u[4], g[4], o[4];
- int i;
+ char buf[18], u[4], g[4], o[4];
+ int i;
- i = 0;
- if (mode & S_IRUSR) u[i++] = 'r';
- if (mode & S_IWUSR) u[i++] = 'w';
- if (mode & S_IXUSR) u[i++] = 'x';
- u[i] = '\0';
-
- i = 0;
- if (mode & S_IRGRP) g[i++] = 'r';
- if (mode & S_IWGRP) g[i++] = 'w';
- if (mode & S_IXGRP) g[i++] = 'x';
- g[i] = '\0';
-
- i = 0;
- if (mode & S_IROTH) o[i++] = 'r';
- if (mode & S_IWOTH) o[i++] = 'w';
- if (mode & S_IXOTH) o[i++] = 'x';
- o[i] = '\0';
-
- sprintf(buf, "u=%s,g=%s,o=%s", u, g, o);
- return xstrdup(buf);
+ i = 0;
+ if (mode & S_IRUSR) u[i++] = 'r';
+ if (mode & S_IWUSR) u[i++] = 'w';
+ if (mode & S_IXUSR) u[i++] = 'x';
+ u[i] = '\0';
+
+ i = 0;
+ if (mode & S_IRGRP) g[i++] = 'r';
+ if (mode & S_IWGRP) g[i++] = 'w';
+ if (mode & S_IXGRP) g[i++] = 'x';
+ g[i] = '\0';
+
+ i = 0;
+ if (mode & S_IROTH) o[i++] = 'r';
+ if (mode & S_IWOTH) o[i++] = 'w';
+ if (mode & S_IXOTH) o[i++] = 'x';
+ o[i] = '\0';
+
+ sprintf(buf, "u=%s,g=%s,o=%s", u, g, o);
+ return xstrdup(buf);
}
/*
@@ -235,214 +264,379 @@ change_mode (filename, mode_string)
#ifdef CLIENT_SUPPORT
-/* The host part of CVSROOT. */
-static char *server_host;
-/* The user part of CVSROOT */
-static char *server_user;
-/* The repository part of CVSROOT. */
-static char *server_cvsroot;
+int client_prune_dirs;
-int client_active;
+static List *ignlist = (List *) NULL;
-int client_prune_dirs;
+/* Buffer to write to the server. */
+static struct buffer *to_server;
+/* The stream underlying to_server, if we are using a stream. */
+static FILE *to_server_fp;
-static int cvsroot_parsed = 0;
+/* Buffer used to read from the server. */
+static struct buffer *from_server;
+/* The stream underlying from_server, if we are using a stream. */
+static FILE *from_server_fp;
-static List *ignlist = (List *) NULL;
+/* Process ID of rsh subprocess. */
+static int rsh_pid = -1;
+
+
+/* This routine is called when one of the buffer routines runs out of
+ memory. */
-/* Set server_host and server_cvsroot. */
static void
-parse_cvsroot ()
+buf_memory_error (buf)
+ struct buffer *buf;
{
- char *p;
-#ifdef AUTH_CLIENT_SUPPORT
- static char *access_method;
-#endif /* AUTH_CLIENT_SUPPORT */
+ error (1, 0, "out of memory");
+}
+
+/* We want to be able to log data sent between us and the server. We
+ do it using log buffers. Each log buffer has another buffer which
+ handles the actual I/O, and a file to log information to.
- /* Don't go through the trouble twice. */
- if (cvsroot_parsed)
- return;
+ This structure is the closure field of a log buffer. */
- server_host = xstrdup (CVSroot);
+struct log_buffer
+{
+ /* The underlying buffer. */
+ struct buffer *buf;
+ /* The file to log information to. */
+ FILE *log;
+};
-#ifdef AUTH_CLIENT_SUPPORT
- if ((server_host[0] == ':'))
- {
- /* Access method specified, as in
- * "cvs -d :pserver:user@host:/path".
- * We need to get past that part of CVSroot before parsing the
- * rest of it.
- */
- access_method = p = &(server_host[1]);
+static struct buffer *log_buffer_initialize
+ PROTO((struct buffer *, FILE *, int, void (*) (struct buffer *)));
+static int log_buffer_input PROTO((void *, char *, int, int, int *));
+static int log_buffer_output PROTO((void *, const char *, int, int *));
+static int log_buffer_flush PROTO((void *));
+static int log_buffer_block PROTO((void *, int));
+static int log_buffer_shutdown PROTO((void *));
+
+/* Create a log buffer. */
+
+static struct buffer *
+log_buffer_initialize (buf, fp, input, memory)
+ struct buffer *buf;
+ FILE *fp;
+ int input;
+ void (*memory) PROTO((struct buffer *));
+{
+ struct log_buffer *n;
+
+ n = (struct log_buffer *) xmalloc (sizeof *n);
+ n->buf = buf;
+ n->log = fp;
+ return buf_initialize (input ? log_buffer_input : NULL,
+ input ? NULL : log_buffer_output,
+ input ? NULL : log_buffer_flush,
+ log_buffer_block,
+ log_buffer_shutdown,
+ memory,
+ n);
+}
- if (! *access_method)
- error (1, 0, "bad CVSroot: %s", CVSroot);
+/* The input function for a log buffer. */
- if (! *(p = strchr (access_method, ':')))
- error (1, 0, "bad CVSroot: %s", CVSroot);
-
- *p = '\0';
- p++;
+static int
+log_buffer_input (closure, data, need, size, got)
+ void *closure;
+ char *data;
+ int need;
+ int size;
+ int *got;
+{
+ struct log_buffer *lb = (struct log_buffer *) closure;
+ int status;
+ size_t n_to_write;
- server_host = p;
-
- if (! *server_host)
- error (1, 0, "bad CVSroot: %s", CVSroot);
+ if (lb->buf->input == NULL)
+ abort ();
- if (strcmp (access_method, "pserver") == 0)
- use_authenticating_server = 1;
- else
- error (1, 0, "unknown access method: %s", access_method);
- }
-#endif /* AUTH_CLIENT_SUPPORT */
-
- /* First get just the pathname. */
- server_cvsroot = strchr (server_host, ':');
- *server_cvsroot = '\0';
- ++server_cvsroot;
-
- /* Then deal with host and possible user. */
- if ( (p = strchr (server_host, '@')) == NULL)
+ status = (*lb->buf->input) (lb->buf->closure, data, need, size, got);
+ if (status != 0)
+ return status;
+
+ if (*got > 0)
{
- server_user = NULL;
+ n_to_write = *got;
+ if (fwrite (data, 1, n_to_write, lb->log) != n_to_write)
+ error (0, errno, "writing to log file");
}
- else
+
+ return 0;
+}
+
+/* The output function for a log buffer. */
+
+static int
+log_buffer_output (closure, data, have, wrote)
+ void *closure;
+ const char *data;
+ int have;
+ int *wrote;
+{
+ struct log_buffer *lb = (struct log_buffer *) closure;
+ int status;
+ size_t n_to_write;
+
+ if (lb->buf->output == NULL)
+ abort ();
+
+ status = (*lb->buf->output) (lb->buf->closure, data, have, wrote);
+ if (status != 0)
+ return status;
+
+ if (*wrote > 0)
{
- server_user = server_host;
- server_host = p;
- ++server_host;
- *p = '\0';
+ n_to_write = *wrote;
+ if (fwrite (data, 1, n_to_write, lb->log) != n_to_write)
+ error (0, errno, "writing to log file");
}
-
- client_active = 1;
- cvsroot_parsed = 1;
+
+ return 0;
+}
+
+/* The flush function for a log buffer. */
+
+static int
+log_buffer_flush (closure)
+ void *closure;
+{
+ struct log_buffer *lb = (struct log_buffer *) closure;
+
+ if (lb->buf->flush == NULL)
+ abort ();
+
+ /* We don't really have to flush the log file here, but doing it
+ will let tail -f on the log file show what is sent to the
+ network as it is sent. */
+ if (fflush (lb->log) != 0)
+ error (0, errno, "flushing log file");
+
+ return (*lb->buf->flush) (lb->buf->closure);
+}
+
+/* The block function for a log buffer. */
+
+static int
+log_buffer_block (closure, block)
+ void *closure;
+ int block;
+{
+ struct log_buffer *lb = (struct log_buffer *) closure;
+
+ if (block)
+ return set_block (lb->buf);
+ else
+ return set_nonblock (lb->buf);
+}
+
+/* The shutdown function for a log buffer. */
+
+static int
+log_buffer_shutdown (closure)
+ void *closure;
+{
+ struct log_buffer *lb = (struct log_buffer *) closure;
+
+ return buf_shutdown (lb->buf);
}
#ifdef NO_SOCKET_TO_FD
+
/* Under certain circumstances, we must communicate with the server
via a socket using send() and recv(). This is because under some
operating systems (OS/2 and Windows 95 come to mind), a socket
cannot be converted to a file descriptor -- it must be treated as a
- socket and nothing else. */
+ socket and nothing else.
+
+ We may also need to deal with socket routine error codes differently
+ in these cases. This is handled through the SOCK_ERRNO and
+ SOCK_STRERROR macros. */
+
static int use_socket_style = 0;
static int server_sock;
-#endif /* NO_SOCKET_TO_FD */
-/* Stream to write to the server. */
-static FILE *to_server;
-/* Stream to read from the server. */
-static FILE *from_server;
+/* These routines implement a buffer structure which uses send and
+ recv. The buffer is always in blocking mode so we don't implement
+ the block routine. */
-/* We might want to log client/server traffic. */
-static FILE *from_server_logfile;
-static FILE *to_server_logfile;
+/* Note that it is important that these routines always handle errors
+ internally and never return a positive errno code, since it would in
+ general be impossible for the caller to know in general whether any
+ error code came from a socket routine (to decide whether to use
+ SOCK_STRERROR or simply strerror to print an error message). */
-#if ! RSH_NOT_TRANSPARENT
-/* Process ID of rsh subprocess. */
-static int rsh_pid = -1;
-#endif /* ! RSH_NOT_TRANSPARENT */
+/* We use an instance of this structure as the closure field. */
-
-/*
- * Read a line from the server. Result does not include the terminating \n.
- *
- * Space for the result is malloc'd and should be freed by the caller.
- *
- * Returns number of bytes read. If EOF_OK, then return 0 on end of file,
- * else end of file is an error.
- */
-static int
-read_line (resultp, eof_ok)
- char **resultp;
- int eof_ok;
+struct socket_buffer
{
- int c;
- char *result;
- size_t input_index = 0;
- size_t result_size = 80;
+ /* The socket number. */
+ int socket;
+};
-#ifdef NO_SOCKET_TO_FD
- if (! use_socket_style)
-#endif /* NO_SOCKET_TO_FD */
- fflush (to_server);
+static struct buffer *socket_buffer_initialize
+ PROTO ((int, int, void (*) (struct buffer *)));
+static int socket_buffer_input PROTO((void *, char *, int, int, int *));
+static int socket_buffer_output PROTO((void *, const char *, int, int *));
+static int socket_buffer_flush PROTO((void *));
- result = (char *) xmalloc (result_size);
+/* Create a buffer based on a socket. */
- while (1)
- {
+static struct buffer *
+socket_buffer_initialize (socket, input, memory)
+ int socket;
+ int input;
+ void (*memory) PROTO((struct buffer *));
+{
+ struct socket_buffer *n;
+
+ n = (struct socket_buffer *) xmalloc (sizeof *n);
+ n->socket = socket;
+ return buf_initialize (input ? socket_buffer_input : NULL,
+ input ? NULL : socket_buffer_output,
+ input ? NULL : socket_buffer_flush,
+ (int (*) PROTO((void *, int))) NULL,
+ (int (*) PROTO((void *))) NULL,
+ memory,
+ n);
+}
-#ifdef NO_SOCKET_TO_FD
- if (use_socket_style)
- {
- char ch;
- /* Yes, this sucks performance-wise. Short of implementing
- our own buffering, I'm not sure how to effect a big
- improvement. We could at least avoid calling
- read_from_server() for each character if we were willing
- to duplicate a lot of its code, but I'm not sure that's
- worth it. */
- read_from_server (&ch, 1);
- c = ch;
- }
- else
-#endif /* NO_SOCKET_TO_FD */
- c = getc (from_server);
+/* The buffer input function for a buffer built on a socket. */
- if (c == EOF)
- {
- free (result);
+static int
+socket_buffer_input (closure, data, need, size, got)
+ void *closure;
+ char *data;
+ int need;
+ int size;
+ int *got;
+{
+ struct socket_buffer *sb = (struct socket_buffer *) closure;
+ int nbytes;
-#ifdef NO_SOCKET_TO_FD
- if (! use_socket_style)
-#endif /* NO_SOCKET_TO_FD */
- if (ferror (from_server))
- error (1, errno, "reading from server");
-
- /* It's end of file. */
- if (eof_ok)
- return 0;
- else
- error (1, 0, "end of file from server (consult above messages if any)");
- }
+ /* I believe that the recv function gives us exactly the semantics
+ we want. If there is a message, it returns immediately with
+ whatever it could get. If there is no message, it waits until
+ one comes in. In other words, it is not like read, which in
+ blocking mode normally waits until all the requested data is
+ available. */
- if (c == '\n')
- break;
-
- result[input_index++] = c;
- while (input_index + 1 >= result_size)
+ *got = 0;
+
+ do
+ {
+ nbytes = recv (sb->socket, data, size, 0);
+ if (nbytes < 0)
+ error (1, 0, "reading from server: %s", SOCK_STRERROR (SOCK_ERRNO));
+ if (nbytes == 0)
{
- result_size *= 2;
- result = (char *) xrealloc (result, result_size);
+ /* End of file (for example, the server has closed
+ the connection). If we've already read something, we
+ just tell the caller about the data, not about the end of
+ file. If we've read nothing, we return end of file. */
+ if (*got == 0)
+ return -1;
+ else
+ return 0;
}
+ need -= nbytes;
+ size -= nbytes;
+ data += nbytes;
+ *got += nbytes;
}
+ while (need > 0);
- if (resultp)
- *resultp = result;
+ return 0;
+}
- /* Terminate it just for kicks, but we *can* deal with embedded NULs. */
- result[input_index] = '\0';
+/* The buffer output function for a buffer built on a socket. */
+
+static int
+socket_buffer_output (closure, data, have, wrote)
+ void *closure;
+ const char *data;
+ int have;
+ int *wrote;
+{
+ struct socket_buffer *sb = (struct socket_buffer *) closure;
+
+ *wrote = have;
+
+#ifdef SEND_NEVER_PARTIAL
+ /* If send() never will produce a partial write, then just do it. This
+ is needed for systems where its return value is something other than
+ the number of bytes written. */
+ if (send (sb->socket, data, have, 0) < 0)
+ error (1, 0, "writing to server socket: %s", SOCK_STRERROR (SOCK_ERRNO));
+#else
+ while (have > 0)
+ {
+ int nbytes;
+
+ nbytes = send (sb->socket, data, have, 0);
+ if (nbytes < 0)
+ error (1, 0, "writing to server socket: %s", SOCK_STRERROR (SOCK_ERRNO));
+
+ have -= nbytes;
+ data += nbytes;
+ }
+#endif
+
+ return 0;
+}
+
+/* The buffer flush function for a buffer built on a socket. */
+
+/*ARGSUSED*/
+static int
+socket_buffer_flush (closure)
+ void *closure;
+{
+ /* Nothing to do. Sockets are always flushed. */
+ return 0;
+}
-#ifdef NO_SOCKET_TO_FD
- if (! use_socket_style)
#endif /* NO_SOCKET_TO_FD */
+
+/*
+ * Read a line from the server. Result does not include the terminating \n.
+ *
+ * Space for the result is malloc'd and should be freed by the caller.
+ *
+ * Returns number of bytes read.
+ */
+static int
+read_line (resultp)
+ char **resultp;
+{
+ int status;
+ char *result;
+ int len;
+
+ status = buf_flush (to_server, 1);
+ if (status != 0)
+ error (1, status, "writing to server");
+
+ status = buf_read_line (from_server, &result, &len);
+ if (status != 0)
{
- /*
- * If we're using socket style, then everything has already
- * been logged because read_from_server() was used to get the
- * individual chars, and read_from_server() logs already.
- */
- if (from_server_logfile)
- {
- if (fwrite (result, 1, input_index, from_server_logfile)
- < input_index)
- error (0, errno, "writing to from-server logfile");
- putc ('\n', from_server_logfile);
- }
+ if (status == -1)
+ error (1, 0, "end of file from server (consult above messages if any)");
+ else if (status == -2)
+ error (1, 0, "out of memory");
+ else
+ error (1, status, "reading from server");
}
-
- if (resultp == NULL)
+
+ if (resultp != NULL)
+ *resultp = result;
+ else
free (result);
- return input_index;
+
+ return len;
}
#endif /* CLIENT_SUPPORT */
@@ -456,23 +650,28 @@ read_line (resultp, eof_ok)
*/
int gzip_level;
+/*
+ * Level of compression to use when running gzip on a single file.
+ */
+int file_gzip_level;
+
int filter_through_gzip (fd, dir, level, pidp)
- int fd, dir, level;
- pid_t *pidp;
+ int fd, dir, level;
+ pid_t *pidp;
{
- static char buf[5] = "-";
- static char *gzip_argv[3] = { "gzip", buf };
+ static char buf[5] = "-";
+ static char *gzip_argv[3] = { "gzip", buf };
- sprintf (buf+1, "%d", level);
- return filter_stream_through_program (fd, dir, &gzip_argv[0], pidp);
+ sprintf (buf+1, "%d", level);
+ return filter_stream_through_program (fd, dir, &gzip_argv[0], pidp);
}
int filter_through_gunzip (fd, dir, pidp)
- int fd, dir;
- pid_t *pidp;
+ int fd, dir;
+ pid_t *pidp;
{
- static char *gunzip_argv[3] = { "gunzip", "-d" };
- return filter_stream_through_program (fd, dir, &gunzip_argv[0], pidp);
+ static char *gunzip_argv[3] = { "gzip", "-d" };
+ return filter_stream_through_program (fd, dir, &gunzip_argv[0], pidp);
}
#endif /* CLIENT_SUPPORT or SERVER_SUPPORT */
@@ -485,8 +684,10 @@ int filter_through_gunzip (fd, dir, pidp)
*/
static char *toplevel_repos;
-/* Working directory when we first started. */
-char toplevel_wd[PATH_MAX];
+/* Working directory when we first started. Note: we could speed things
+ up on some systems by using savecwd.h here instead of just always
+ storing a name. */
+char *toplevel_wd;
static void
handle_ok (args, len)
@@ -559,9 +760,6 @@ handle_valid_requests (args, len)
*/
send_to_server (rq->name, 0);
send_to_server ("\012", 0);
-
- if (!strcmp("UseUnchanged",rq->name))
- use_unchanged = 1;
}
else
rq->status = rq_supported;
@@ -577,26 +775,10 @@ handle_valid_requests (args, len)
}
}
-static int use_directory = -1;
-
-static char *get_short_pathname PROTO((const char *));
-
-static char *
-get_short_pathname (name)
- const char *name;
-{
- const char *retval;
- if (use_directory)
- return (char *) name;
- if (strncmp (name, toplevel_repos, strlen (toplevel_repos)) != 0)
- error (1, 0, "server bug: name `%s' doesn't specify file in `%s'",
- name, toplevel_repos);
- retval = name + strlen (toplevel_repos) + 1;
- if (retval[-1] != '/')
- error (1, 0, "server bug: name `%s' doesn't specify file in `%s'",
- name, toplevel_repos);
- return (char *) retval;
-}
+/* This variable holds the result of Entries_Open, so that we can
+ close Entries_Close on it when we move on to a new directory, or
+ when we finish. */
+static List *last_entries;
/*
* Do all the processing for PATHNAME, where pathname consists of the
@@ -618,12 +800,15 @@ call_in_directory (pathname, func, data)
char *filename));
char *data;
{
- static List *last_entries;
-
char *dir_name;
char *filename;
- /* Just the part of pathname relative to toplevel_repos. */
- char *short_pathname = get_short_pathname (pathname);
+ /* This is what we get when we hook up the directory (working directory
+ name) from PATHNAME with the filename from REPOSNAME. For example:
+ pathname: ccvs/src/
+ reposname: /u/src/master/ccvs/foo/ChangeLog
+ short_pathname: ccvs/src/ChangeLog
+ */
+ char *short_pathname;
char *p;
/*
@@ -646,30 +831,23 @@ call_in_directory (pathname, func, data)
int reposdirname_absolute;
reposname = NULL;
- if (use_directory)
- read_line (&reposname, 0);
+ read_line (&reposname);
+ assert (reposname != NULL);
reposdirname_absolute = 0;
- if (reposname != NULL)
+ if (strncmp (reposname, toplevel_repos, strlen (toplevel_repos)) != 0)
+ {
+ reposdirname_absolute = 1;
+ short_repos = reposname;
+ }
+ else
{
- if (strncmp (reposname, toplevel_repos, strlen (toplevel_repos)) != 0)
+ short_repos = reposname + strlen (toplevel_repos) + 1;
+ if (short_repos[-1] != '/')
{
reposdirname_absolute = 1;
short_repos = reposname;
}
- else
- {
- short_repos = reposname + strlen (toplevel_repos) + 1;
- if (short_repos[-1] != '/')
- {
- reposdirname_absolute = 1;
- short_repos = reposname;
- }
- }
- }
- else
- {
- short_repos = short_pathname;
}
reposdirname = xstrdup (short_repos);
p = strrchr (reposdirname, '/');
@@ -681,7 +859,7 @@ call_in_directory (pathname, func, data)
else
*p = '\0';
- dir_name = xstrdup (short_pathname);
+ dir_name = xstrdup (pathname);
p = strrchr (dir_name, '/');
if (p == NULL)
{
@@ -699,30 +877,66 @@ call_in_directory (pathname, func, data)
else
++filename;
- if (reposname != NULL)
- {
- /* This is the use_directory case. */
-
- short_pathname = xmalloc (strlen (pathname) + strlen (filename) + 5);
- strcpy (short_pathname, pathname);
- strcat (short_pathname, filename);
- }
+ short_pathname = xmalloc (strlen (pathname) + strlen (filename) + 5);
+ strcpy (short_pathname, pathname);
+ strcat (short_pathname, filename);
if (last_dir_name == NULL
|| strcmp (last_dir_name, dir_name) != 0)
{
+ int newdir;
+
+ if (strcmp (command_name, "export") != 0)
+ if (last_entries)
+ Entries_Close (last_entries);
+
if (last_dir_name)
free (last_dir_name);
last_dir_name = dir_name;
- if (toplevel_wd[0] == '\0')
- if (getwd (toplevel_wd) == NULL)
- error (1, 0,
- "could not get working directory: %s", toplevel_wd);
+ if (toplevel_wd == NULL)
+ {
+ toplevel_wd = xgetwd ();
+ if (toplevel_wd == NULL)
+ error (1, errno, "could not get working directory");
+ }
- if (chdir (toplevel_wd) < 0)
+ if (CVS_CHDIR (toplevel_wd) < 0)
error (1, errno, "could not chdir to %s", toplevel_wd);
- if (chdir (dir_name) < 0)
+ newdir = 0;
+
+ /* Create the CVS directory at the top level if needed.
+ The isdir seems like an unneeded system call, but it *does*
+ need to be called both if the CVS_CHDIR below succeeds (e.g.
+ "cvs co .") or if it fails (e.g. basicb-1a in testsuite). */
+ if (/* I think the reposdirname_absolute case has to do with
+ things like "cvs update /foo/bar". In any event, the
+ code below which tries to put toplevel_repos into
+ CVS/Repository is almost surely unsuited to
+ the reposdirname_absolute case. */
+ !reposdirname_absolute
+
+ && ! isdir (CVSADM))
+ {
+ char *repo;
+ char *r;
+
+ newdir = 1;
+
+ repo = xmalloc (strlen (toplevel_repos)
+ + 10);
+ strcpy (repo, toplevel_repos);
+ r = repo + strlen (repo);
+ if (r[-1] != '.' || r[-2] != '/')
+ strcpy (r, "/.");
+
+ Create_Admin (".", ".", repo, (char *) NULL,
+ (char *) NULL, 0);
+
+ free (repo);
+ }
+
+ if ( CVS_CHDIR (dir_name) < 0)
{
char *dir;
char *dirp;
@@ -731,6 +945,13 @@ call_in_directory (pathname, func, data)
error (1, errno, "could not chdir to %s", dir_name);
/* Directory does not exist, we need to create it. */
+ newdir = 1;
+
+ /* Provided we are willing to assume that directories get
+ created one at a time, we could simplify this a lot.
+ Do note that one aspect still would need to walk the
+ dir_name path: the checking for "fncmp (dir, CVSADM)". */
+
dir = xmalloc (strlen (dir_name) + 1);
dirp = dir_name;
rdirp = reposdirname;
@@ -759,19 +980,21 @@ call_in_directory (pathname, func, data)
{
dirp = strchr (dirp, '/');
if (dirp)
- {
+ {
strncpy (dir, dir_name, dirp - dir_name);
dir[dirp - dir_name] = '\0';
/* Skip the slash. */
++dirp;
if (rdirp == NULL)
- error (0, 0,
- "internal error: repository string too short.");
+ /* This just means that the repository string has
+ fewer components than the dir_name string. But
+ that is OK (e.g. see modules3-8 in testsuite). */
+ ;
else
- rdirp = strchr (rdirp, '/');
- }
+ rdirp = strchr (rdirp, '/');
+ }
else
- {
+ {
/* If there are no more slashes in the dir name,
we're down to the most nested directory -OR- to
the name of a module. In the first case, we
@@ -789,35 +1012,19 @@ call_in_directory (pathname, func, data)
rdirp = NULL;
strcpy (dir, dir_name);
- }
+ }
+
+ if (fncmp (dir, CVSADM) == 0)
+ {
+ error (0, 0, "cannot create a directory named %s", dir);
+ error (0, 0, "because CVS uses \"%s\" for its own uses",
+ CVSADM);
+ error (1, 0, "rename the directory and try again");
+ }
- if (CVS_MKDIR (dir, 0777) < 0)
+ if (mkdir_if_needed (dir))
{
- /* Now, let me get this straight. In IBM C/C++
- * under OS/2, the error string for EEXIST is:
- *
- * "The file already exists",
- *
- * and the error string for EACCESS is:
- *
- * "The file or directory specified is read-only".
- *
- * Nonetheless, mkdir() will set EACCESS if the
- * directory *exists*, according both to the
- * documentation and its actual behavior.
- *
- * I'm sure that this made sense, to someone,
- * somewhere, sometime. Just not me, here, now.
- */
-#ifdef EACCESS
- if ((errno != EACCESS) && (errno != EEXIST))
- error (1, errno, "cannot make directory %s", dir);
-#else /* ! defined(EACCESS) */
- if ((errno != EEXIST))
- error (1, errno, "cannot make directory %s", dir);
-#endif /* defined(EACCESS) */
-
- /* It already existed, fine. Just keep going. */
+ /* It already existed, fine. Just keep going. */
}
else if (strcmp (command_name, "export") == 0)
/* Don't create CVSADM directories if this is export. */
@@ -831,7 +1038,7 @@ call_in_directory (pathname, func, data)
* relative to cvsroot.
*/
char *repo;
- char *r;
+ char *r, *b;
repo = xmalloc (strlen (reposdirname)
+ strlen (toplevel_repos)
@@ -847,6 +1054,13 @@ call_in_directory (pathname, func, data)
if (rdirp)
{
+ /* See comment near start of function; the only
+ way that the server can put the right thing
+ in each CVS/Repository file is to create the
+ directories one at a time. I think that the
+ CVS server has been doing this all along. */
+ error (0, 0, "\
+warning: server is not creating directories one at a time");
strncpy (r, reposdirname, rdirp - reposdirname);
r[rdirp - reposdirname] = '\0';
}
@@ -854,8 +1068,18 @@ call_in_directory (pathname, func, data)
strcpy (r, reposdirname);
Create_Admin (dir, dir, repo,
- (char *)NULL, (char *)NULL);
+ (char *)NULL, (char *)NULL, 0);
free (repo);
+
+ b = strrchr (dir, '/');
+ if (b == NULL)
+ Subdir_Register ((List *) NULL, (char *) NULL, dir);
+ else
+ {
+ *b = '\0';
+ Subdir_Register ((List *) NULL, dir, b + 1);
+ *b = '/';
+ }
}
if (rdirp != NULL)
@@ -867,26 +1091,42 @@ call_in_directory (pathname, func, data)
} while (dirp != NULL);
free (dir);
/* Now it better work. */
- if (chdir (dir_name) < 0)
+ if ( CVS_CHDIR (dir_name) < 0)
error (1, errno, "could not chdir to %s", dir_name);
}
if (strcmp (command_name, "export") != 0)
{
- if (last_entries)
- Entries_Close (last_entries);
last_entries = Entries_Open (0);
+
+ /* If this is a newly created directory, we will record
+ all subdirectory information, so call Subdirs_Known in
+ case there are no subdirectories. If this is not a
+ newly created directory, it may be an old working
+ directory from before we recorded subdirectory
+ information in the Entries file. We force a search for
+ all subdirectories now, to make sure our subdirectory
+ information is up to date. If the Entries file does
+ record subdirectory information, then this call only
+ does list manipulation. */
+ if (newdir)
+ Subdirs_Known (last_entries);
+ else
+ {
+ List *dirlist;
+
+ dirlist = Find_Directories ((char *) NULL, W_LOCAL,
+ last_entries);
+ dellist (&dirlist);
+ }
}
}
else
free (dir_name);
free (reposdirname);
(*func) (data, last_entries, short_pathname, filename);
- if (reposname != NULL)
- {
- free (short_pathname);
- free (reposname);
- }
+ free (short_pathname);
+ free (reposname);
}
static void
@@ -901,7 +1141,7 @@ copy_a_file (data, ent_list, short_pathname, filename)
char *p;
#endif
- read_line (&newname, 0);
+ read_line (&newname);
#ifdef USE_VMS_FILENAMES
/* Mogrify the filename so VMS is happy with it. */
@@ -949,7 +1189,7 @@ read_counted_file (filename, fullname)
FILE *fp;
- read_line (&size_string, 0);
+ read_line (&size_string);
if (size_string[0] == 'z')
error (1, 0, "\
protocol error: compressed files not supported for that operation");
@@ -968,7 +1208,7 @@ protocol error: compressed files not supported for that operation");
is binary or not. I haven't carefully looked into whether
CVS/Template files should use local text file conventions or
not. */
- fp = fopen (filename, "wb");
+ fp = CVS_FOPEN (filename, "wb");
if (fp == NULL)
error (1, errno, "cannot write %s", fullname);
nread = size;
@@ -1002,6 +1242,11 @@ protocol error: compressed files not supported for that operation");
}
/*
+ * The time stamp of the last file we registered.
+ */
+static time_t last_register_time;
+
+/*
* The Checksum response gives the checksum for the file transferred
* over by the next Updated, Merged or Patch response. We just store
* it here, and then check it in update_entries.
@@ -1082,9 +1327,23 @@ struct update_entries_data
* We are getting a patch against the existing local file, not
* an entire new file.
*/
- UPDATE_ENTRIES_PATCH
+ UPDATE_ENTRIES_PATCH,
+ /*
+ * We are getting an RCS change text (diff -n output) against
+ * the existing local file, not an entire new file.
+ */
+ UPDATE_ENTRIES_RCS_DIFF
} contents;
+ enum {
+ /* We are replacing an existing file. */
+ UPDATE_ENTRIES_EXISTING,
+ /* We are creating a new file. */
+ UPDATE_ENTRIES_NEW,
+ /* We don't know whether it is existing or new. */
+ UPDATE_ENTRIES_EXISTING_OR_NEW
+ } existp;
+
/*
* String to put in the timestamp field or NULL to use the timestamp
* of the file.
@@ -1109,13 +1368,13 @@ update_entries (data_arg, ent_list, short_pathname, filename)
/* Timestamp field. Always empty according to the protocol. */
char *ts;
char *options;
- char *tag;
- char *date;
+ char *tag = NULL;
+ char *date = NULL;
char *tag_or_date;
- char *scratch_entries;
+ char *scratch_entries = NULL;
int bin;
- read_line (&entries_line, 0);
+ read_line (&entries_line);
/*
* Parse the entries line.
@@ -1149,8 +1408,6 @@ update_entries (data_arg, ent_list, short_pathname, filename)
cp = strchr (tag_or_date, '/');
if (cp != NULL)
*cp = '\0';
- tag = (char *) NULL;
- date = (char *) NULL;
if (*tag_or_date == 'T')
tag = tag_or_date + 1;
else if (*tag_or_date == 'D')
@@ -1167,20 +1424,20 @@ update_entries (data_arg, ent_list, short_pathname, filename)
options = NULL;
if (data->contents == UPDATE_ENTRIES_UPDATE
- || data->contents == UPDATE_ENTRIES_PATCH)
+ || data->contents == UPDATE_ENTRIES_PATCH
+ || data->contents == UPDATE_ENTRIES_RCS_DIFF)
{
char *size_string;
char *mode_string;
int size;
- int fd;
char *buf;
char *temp_filename;
- int use_gzip, gzip_status;
- pid_t gzip_pid = 0;
+ int use_gzip;
+ int patch_failed;
- read_line (&mode_string, 0);
+ read_line (&mode_string);
- read_line (&size_string, 0);
+ read_line (&size_string);
if (size_string[0] == 'z')
{
use_gzip = 1;
@@ -1193,6 +1450,74 @@ update_entries (data_arg, ent_list, short_pathname, filename)
}
free (size_string);
+ /* Note that checking this separately from writing the file is
+ a race condition: if the existing or lack thereof of the
+ file changes between now and the actually calls which
+ operate on it, we lose. However (a) there are so many
+ cases, I'm reluctant to try to fix them all, (b) in some
+ cases the system might not even have a system call which
+ does the right thing, and (c) it isn't clear this needs to
+ work. */
+ if (data->existp == UPDATE_ENTRIES_EXISTING
+ && !isfile (filename))
+ /* Emit a warning and update the file anyway. */
+ error (0, 0, "warning: %s unexpectedly disappeared",
+ short_pathname);
+
+ if (data->existp == UPDATE_ENTRIES_NEW
+ && isfile (filename))
+ {
+ /* Emit a warning and refuse to update the file; we don't want
+ to clobber a user's file. */
+ size_t nread;
+ size_t toread;
+
+ /* size should be unsigned, but until we get around to fixing
+ that, work around it. */
+ size_t usize;
+
+ char buf[8192];
+
+ /* This error might be confusing; it isn't really clear to
+ the user what to do about it. Keep in mind that it has
+ several causes: (1) something/someone creates the file
+ during the time that CVS is running, (2) the repository
+ has two files whose names clash for the client because
+ of case-insensitivity or similar causes, (3) a special
+ case of this is that a file gets renamed for example
+ from a.c to A.C. A "cvs update" on a case-insensitive
+ client will get this error. Repeating the update takes
+ care of the problem, but is it clear to the user what
+ is going on and what to do about it?, (4) the client
+ has a file which the server doesn't know about (e.g. "?
+ foo" file), and that name clashes with a file the
+ server does know about, (5) classify.c will print the same
+ message for other reasons.
+
+ I hope the above paragraph makes it clear that making this
+ clearer is not a one-line fix. */
+ error (0, 0, "move away %s; it is in the way", short_pathname);
+
+ discard_file_and_return:
+ /* Now read and discard the file contents. */
+ usize = size;
+ nread = 0;
+ while (nread < usize)
+ {
+ toread = usize - nread;
+ if (toread > sizeof buf)
+ toread = sizeof buf;
+
+ nread += try_read_from_server (buf, toread);
+ if (nread == usize)
+ break;
+ }
+
+ free (mode_string);
+ free (entries_line);
+ return;
+ }
+
temp_filename = xmalloc (strlen (filename) + 80);
#ifdef USE_VMS_FILENAMES
/* A VMS rename of "blah.dat" to "foo" to implies a
@@ -1205,6 +1530,7 @@ update_entries (data_arg, ent_list, short_pathname, filename)
sprintf (temp_filename, ".new.%s", filename);
#endif /* _POSIX_NO_TRUNC */
#endif /* USE_VMS_FILENAMES */
+
buf = xmalloc (size);
/* Some systems, like OS/2 and Windows NT, end lines with CRLF
@@ -1219,36 +1545,66 @@ update_entries (data_arg, ent_list, short_pathname, filename)
else
bin = 0;
- fd = open (temp_filename,
- O_WRONLY | O_CREAT | O_TRUNC | (bin ? OPEN_BINARY : 0),
- 0777);
-
- if (fd < 0)
- error (1, errno, "writing %s", short_pathname);
+ if (data->contents == UPDATE_ENTRIES_RCS_DIFF)
+ {
+ /* This is an RCS change text. We just hold the change
+ text in memory. */
- if (use_gzip)
- fd = filter_through_gunzip (fd, 0, &gzip_pid);
+ if (use_gzip)
+ error (1, 0,
+ "server error: gzip invalid with RCS change text");
- if (size > 0)
- {
- read_from_server (buf, size);
-
- if (write (fd, buf, size) != size)
- error (1, errno, "writing %s", short_pathname);
+ read_from_server (buf, size);
}
-
- if (close (fd) < 0)
- error (1, errno, "writing %s", short_pathname);
- if (gzip_pid > 0)
+ else
{
- if (waitpid (gzip_pid, &gzip_status, 0) == -1)
- error (1, errno, "waiting for gzip process %ld",
- (long) gzip_pid);
- else if (gzip_status != 0)
- error (1, 0, "gzip process exited %d", gzip_status);
- }
+ int fd;
+ pid_t gzip_pid = 0;
+
+ fd = CVS_OPEN (temp_filename,
+ (O_WRONLY | O_CREAT | O_TRUNC
+ | (bin ? OPEN_BINARY : 0)),
+ 0777);
+
+ if (fd < 0)
+ {
+ /* I can see a case for making this a fatal error; for
+ a condition like disk full or network unreachable
+ (for a file server), carrying on and giving an
+ error on each file seems unnecessary. But if it is
+ a permission problem, or some such, then it is
+ entirely possible that future files will not have
+ the same problem. */
+ error (0, errno, "cannot write %s", short_pathname);
+ goto discard_file_and_return;
+ }
+
+ if (use_gzip)
+ fd = filter_through_gunzip (fd, 0, &gzip_pid);
+
+ if (size > 0)
+ {
+ read_from_server (buf, size);
+
+ if (write (fd, buf, size) != size)
+ error (1, errno, "writing %s", short_pathname);
+ }
+
+ if (close (fd) < 0)
+ error (1, errno, "writing %s", short_pathname);
+ if (gzip_pid > 0)
+ {
+ int gzip_status;
- gzip_pid = -1;
+ if (waitpid (gzip_pid, &gzip_status, 0) == -1)
+ error (1, errno, "waiting for gzip process %ld",
+ (long) gzip_pid);
+ else if (gzip_status != 0)
+ error (1, 0, "gzip process exited %d", gzip_status);
+ }
+
+ gzip_pid = -1;
+ }
/* Since gunzip writes files without converting LF to CRLF
(a reasonable behavior), we now have a patch file in LF
@@ -1256,6 +1612,8 @@ update_entries (data_arg, ent_list, short_pathname, filename)
it to patch; patch can handle it. However, if it's the
final source file, convert it. */
+ patch_failed = 0;
+
if (data->contents == UPDATE_ENTRIES_UPDATE)
{
#ifdef LINES_CRLF_TERMINATED
@@ -1267,30 +1625,51 @@ update_entries (data_arg, ent_list, short_pathname, filename)
{
convert_file (temp_filename, O_RDONLY | OPEN_BINARY,
filename, O_WRONLY | O_CREAT | O_TRUNC);
- if (unlink (temp_filename) < 0)
+ if ( CVS_UNLINK (temp_filename) < 0)
error (0, errno, "warning: couldn't delete %s",
temp_filename);
}
else
+#ifdef BROKEN_READWRITE_CONVERSION
+ {
+ /* If only stdio, not open/write/etc., do text/binary
+ conversion, use convert_file which can compensate
+ (FIXME: we could just use stdio instead which would
+ avoid the whole problem). */
+ if (!bin)
+ {
+ convert_file (temp_filename, O_RDONLY | OPEN_BINARY,
+ filename, O_WRONLY | O_CREAT | O_TRUNC);
+ if (CVS_UNLINK (temp_filename) < 0)
+ error (0, errno, "warning: couldn't delete %s",
+ temp_filename);
+ }
+ else
+ rename_file (temp_filename, filename);
+ }
+#else
rename_file (temp_filename, filename);
+#endif
#else /* ! LINES_CRLF_TERMINATED */
rename_file (temp_filename, filename);
#endif /* LINES_CRLF_TERMINATED */
}
- else
+ else if (data->contents == UPDATE_ENTRIES_PATCH)
{
int retcode;
- char backup[PATH_MAX];
+ char *backup;
struct stat s;
- (void) sprintf (backup, "%s~", filename);
+ backup = xmalloc (strlen (filename) + 5);
+ strcpy (backup, filename);
+ strcat (backup, "~");
(void) unlink_file (backup);
if (!isfile (filename))
error (1, 0, "patch original file %s does not exist",
short_pathname);
- if (stat (temp_filename, &s) < 0)
- error (1, 1, "can't stat patch file %s", temp_filename);
+ if ( CVS_STAT (temp_filename, &s) < 0)
+ error (1, errno, "can't stat patch file %s", temp_filename);
if (s.st_size == 0)
retcode = 0;
else
@@ -1322,27 +1701,126 @@ update_entries (data_arg, ent_list, short_pathname, filename)
(void) unlink_file (path_tmp);
free (path_tmp);
- /* Save this file to retrieve later. */
- failed_patches =
- (char **) xrealloc ((char *) failed_patches,
- ((failed_patches_count + 1)
- * sizeof (char *)));
- failed_patches[failed_patches_count] =
- xstrdup (short_pathname);
- ++failed_patches_count;
-
error (retcode == -1 ? 1 : 0, retcode == -1 ? old_errno : 0,
"could not patch %s%s", filename,
retcode == -1 ? "" : "; will refetch");
- stored_checksum_valid = 0;
+ patch_failed = 1;
+ }
+ free (backup);
+ }
+ else
+ {
+ struct stat s;
+ char *filebuf, *tobuf;
+ size_t filebufsize;
+ FILE *e;
+ size_t nread;
+ char *patchedbuf;
+ size_t patchedlen;
+
+ /* Handle UPDATE_ENTRIES_RCS_DIFF. */
+
+ if (!isfile (filename))
+ error (1, 0, "patch original file %s does not exist",
+ short_pathname);
+ if (CVS_STAT (filename, &s) < 0)
+ error (1, errno, "can't stat %s", short_pathname);
+
+ filebufsize = s.st_size;
+ filebuf = xmalloc (filebufsize);
+
+ e = open_file (filename, bin ? FOPEN_BINARY_READ : "r");
+
+ tobuf = filebuf;
+ nread = 0;
+ while (1)
+ {
+ size_t got;
+
+ got = fread (tobuf, 1, filebufsize - (tobuf - filebuf), e);
+ if (ferror (e))
+ error (1, errno, "can't read %s", short_pathname);
+ nread += got;
+ tobuf += got;
+
+ if (feof (e))
+ break;
+
+ /* It's probably paranoid to think S.ST_SIZE might be
+ too small to hold the entire file contents, but we
+ handle it just in case. */
+ if (tobuf == filebuf + filebufsize)
+ {
+ int c;
+ long off;
+
+ c = getc (e);
+ if (c == EOF)
+ break;
+ off = tobuf - filebuf;
+ expand_string (&filebuf, &filebufsize, filebufsize + 100);
+ tobuf = filebuf + off;
+ *tobuf++ = c;
+ ++nread;
+ }
+ }
+
+ fclose (e);
+
+ /* At this point the contents of the existing file are in
+ FILEBUF, and the length of the contents is in NREAD.
+ The contents of the patch from the network are in BUF,
+ and the length of the patch is in SIZE. */
+
+ if (! rcs_change_text (short_pathname, filebuf, nread, buf, size,
+ &patchedbuf, &patchedlen))
+ patch_failed = 1;
+ else
+ {
+ if (stored_checksum_valid)
+ {
+ struct MD5Context context;
+ unsigned char checksum[16];
+
+ /* We have a checksum. Check it before writing
+ the file out, so that we don't have to read it
+ back in again. */
+ MD5Init (&context);
+ MD5Update (&context, patchedbuf, patchedlen);
+ MD5Final (checksum, &context);
+ if (memcmp (checksum, stored_checksum, 16) != 0)
+ {
+ error (0, 0,
+ "checksum failure after patch to %s; will refetch",
+ short_pathname);
+
+ patch_failed = 1;
+ }
+
+ stored_checksum_valid = 0;
+ }
- return;
+ if (! patch_failed)
+ {
+ e = open_file (temp_filename,
+ bin ? FOPEN_BINARY_WRITE : "w");
+ if (fwrite (patchedbuf, 1, patchedlen, e) != patchedlen)
+ error (1, errno, "cannot write %s", temp_filename);
+ if (fclose (e) == EOF)
+ error (1, errno, "cannot close %s", temp_filename);
+ rename_file (temp_filename, filename);
+ }
+
+ free (patchedbuf);
}
+
+ free (filebuf);
}
+
free (temp_filename);
- if (stored_checksum_valid)
+ if (stored_checksum_valid && ! patch_failed)
{
FILE *e;
struct MD5Context context;
@@ -1360,7 +1838,7 @@ update_entries (data_arg, ent_list, short_pathname, filename)
* here using text mode, so its lines will be terminated the same
* way they were transmitted.
*/
- e = fopen (filename, "r");
+ e = CVS_FOPEN (filename, "r");
if (e == NULL)
error (1, errno, "could not open %s", short_pathname);
@@ -1385,19 +1863,27 @@ update_entries (data_arg, ent_list, short_pathname, filename)
"checksum failure after patch to %s; will refetch",
short_pathname);
- /* Save this file to retrieve later. */
- failed_patches =
- (char **) xrealloc ((char *) failed_patches,
- ((failed_patches_count + 1)
- * sizeof (char *)));
- failed_patches[failed_patches_count] =
- xstrdup (short_pathname);
- ++failed_patches_count;
-
- return;
+ patch_failed = 1;
}
}
+ if (patch_failed)
+ {
+ /* Save this file to retrieve later. */
+ failed_patches = (char **) xrealloc ((char *) failed_patches,
+ ((failed_patches_count + 1)
+ * sizeof (char *)));
+ failed_patches[failed_patches_count] = xstrdup (short_pathname);
+ ++failed_patches_count;
+
+ stored_checksum_valid = 0;
+
+ free (mode_string);
+ free (buf);
+
+ return;
+ }
+
{
/* FIXME: we should be respecting the umask. */
int status = change_mode (filename, mode_string);
@@ -1422,6 +1908,8 @@ update_entries (data_arg, ent_list, short_pathname, filename)
char *local_timestamp;
char *file_timestamp;
+ (void) time (&last_register_time);
+
local_timestamp = data->timestamp;
if (local_timestamp == NULL || ts[0] == '+')
file_timestamp = time_stamp (filename);
@@ -1459,6 +1947,7 @@ handle_checked_in (args, len)
{
struct update_entries_data dat;
dat.contents = UPDATE_ENTRIES_CHECKIN;
+ dat.existp = UPDATE_ENTRIES_EXISTING_OR_NEW;
dat.timestamp = NULL;
call_in_directory (args, update_entries, (char *)&dat);
}
@@ -1470,6 +1959,7 @@ handle_new_entry (args, len)
{
struct update_entries_data dat;
dat.contents = UPDATE_ENTRIES_CHECKIN;
+ dat.existp = UPDATE_ENTRIES_EXISTING_OR_NEW;
dat.timestamp = "dummy timestamp from new-entry";
call_in_directory (args, update_entries, (char *)&dat);
}
@@ -1481,6 +1971,35 @@ handle_updated (args, len)
{
struct update_entries_data dat;
dat.contents = UPDATE_ENTRIES_UPDATE;
+ dat.existp = UPDATE_ENTRIES_EXISTING_OR_NEW;
+ dat.timestamp = NULL;
+ call_in_directory (args, update_entries, (char *)&dat);
+}
+
+static void handle_created PROTO((char *, int));
+
+static void
+handle_created (args, len)
+ char *args;
+ int len;
+{
+ struct update_entries_data dat;
+ dat.contents = UPDATE_ENTRIES_UPDATE;
+ dat.existp = UPDATE_ENTRIES_NEW;
+ dat.timestamp = NULL;
+ call_in_directory (args, update_entries, (char *)&dat);
+}
+
+static void handle_update_existing PROTO((char *, int));
+
+static void
+handle_update_existing (args, len)
+ char *args;
+ int len;
+{
+ struct update_entries_data dat;
+ dat.contents = UPDATE_ENTRIES_UPDATE;
+ dat.existp = UPDATE_ENTRIES_EXISTING;
dat.timestamp = NULL;
call_in_directory (args, update_entries, (char *)&dat);
}
@@ -1492,6 +2011,8 @@ handle_merged (args, len)
{
struct update_entries_data dat;
dat.contents = UPDATE_ENTRIES_UPDATE;
+ /* Think this could be UPDATE_ENTRIES_EXISTING, but just in case... */
+ dat.existp = UPDATE_ENTRIES_EXISTING_OR_NEW;
dat.timestamp = "Result of merge";
call_in_directory (args, update_entries, (char *)&dat);
}
@@ -1503,6 +2024,21 @@ handle_patched (args, len)
{
struct update_entries_data dat;
dat.contents = UPDATE_ENTRIES_PATCH;
+ /* Think this could be UPDATE_ENTRIES_EXISTING, but just in case... */
+ dat.existp = UPDATE_ENTRIES_EXISTING_OR_NEW;
+ dat.timestamp = NULL;
+ call_in_directory (args, update_entries, (char *)&dat);
+}
+
+static void
+handle_rcs_diff (args, len)
+ char *args;
+ int len;
+{
+ struct update_entries_data dat;
+ dat.contents = UPDATE_ENTRIES_RCS_DIFF;
+ /* Think this could be UPDATE_ENTRIES_EXISTING, but just in case... */
+ dat.existp = UPDATE_ENTRIES_EXISTING_OR_NEW;
dat.timestamp = NULL;
call_in_directory (args, update_entries, (char *)&dat);
}
@@ -1533,6 +2069,11 @@ remove_entry_and_file (data, ent_list, short_pathname, filename)
char *filename;
{
Scratch_Entry (ent_list, filename);
+ /* Note that we don't ignore existence_error's here. The server
+ should be sending Remove-entry rather than Removed in cases
+ where the file does not exist. And if the user removes the
+ file halfway through a cvs command, we should be printing an
+ error. */
if (unlink_file (filename) < 0)
error (0, errno, "unable to remove %s", short_pathname);
}
@@ -1550,28 +2091,10 @@ static int
is_cvsroot_level (pathname)
char *pathname;
{
- char *short_pathname;
-
- if (strcmp (toplevel_repos, server_cvsroot) != 0)
+ if (strcmp (toplevel_repos, CVSroot_directory) != 0)
return 0;
- if (!use_directory)
- {
- if (strncmp (pathname, server_cvsroot, strlen (server_cvsroot)) != 0)
- error (1, 0,
- "server bug: pathname `%s' doesn't specify file in `%s'",
- pathname, server_cvsroot);
- short_pathname = pathname + strlen (server_cvsroot) + 1;
- if (short_pathname[-1] != '/')
- error (1, 0,
- "server bug: pathname `%s' doesn't specify file in `%s'",
- pathname, server_cvsroot);
- return strchr (short_pathname, '/') == NULL;
- }
- else
- {
- return strchr (pathname, '/') == NULL;
- }
+ return strchr (pathname, '/') == NULL;
}
static void
@@ -1595,7 +2118,7 @@ handle_set_static_directory (args, len)
if (strcmp (command_name, "export") == 0)
{
/* Swallow the repository. */
- read_line (NULL, 0);
+ read_line (NULL);
return;
}
call_in_directory (args, set_static, (char *)NULL);
@@ -1620,7 +2143,7 @@ handle_clear_static_directory (pathname, len)
if (strcmp (command_name, "export") == 0)
{
/* Swallow the repository. */
- read_line (NULL, 0);
+ read_line (NULL);
return;
}
@@ -1645,7 +2168,7 @@ set_sticky (data, ent_list, short_pathname, filename)
char *tagspec;
FILE *f;
- read_line (&tagspec, 0);
+ read_line (&tagspec);
f = open_file (CVSADM_TAG, "w+");
if (fprintf (f, "%s\n", tagspec) < 0)
error (1, errno, "writing %s", CVSADM_TAG);
@@ -1662,9 +2185,9 @@ handle_set_sticky (pathname, len)
if (strcmp (command_name, "export") == 0)
{
/* Swallow the repository. */
- read_line (NULL, 0);
+ read_line (NULL);
/* Swallow the tag line. */
- (void) read_line (NULL, 0);
+ read_line (NULL);
return;
}
if (is_cvsroot_level (pathname))
@@ -1675,9 +2198,9 @@ handle_set_sticky (pathname, len)
*/
/* Swallow the repository. */
- read_line (NULL, 0);
+ read_line (NULL);
/* Swallow the tag line. */
- (void) read_line (NULL, 0);
+ read_line (NULL);
return;
}
@@ -1703,7 +2226,7 @@ handle_clear_sticky (pathname, len)
if (strcmp (command_name, "export") == 0)
{
/* Swallow the repository. */
- read_line (NULL, 0);
+ read_line (NULL);
return;
}
@@ -1766,7 +2289,7 @@ handle_set_checkin_prog (args, len)
{
char *prog;
struct save_prog *p;
- read_line (&prog, 0);
+ read_line (&prog);
p = (struct save_prog *) xmalloc (sizeof (struct save_prog));
p->next = checkin_progs;
p->dir = xstrdup (args);
@@ -1781,7 +2304,7 @@ handle_set_update_prog (args, len)
{
char *prog;
struct save_prog *p;
- read_line (&prog, 0);
+ read_line (&prog);
p = (struct save_prog *) xmalloc (sizeof (struct save_prog));
p->next = update_progs;
p->dir = xstrdup (args);
@@ -1797,15 +2320,17 @@ do_deferred_progs ()
struct save_prog *p;
struct save_prog *q;
- char fname[PATH_MAX];
+ char *fname;
FILE *f;
- if (toplevel_wd[0] != '\0')
- {
- if (chdir (toplevel_wd) < 0)
- error (1, errno, "could not chdir to %s", toplevel_wd);
- }
+
+ if (toplevel_wd != NULL)
+ {
+ if (CVS_CHDIR (toplevel_wd) < 0)
+ error (1, errno, "could not chdir to %s", toplevel_wd);
+ }
for (p = checkin_progs; p != NULL; )
{
+ fname = xmalloc (strlen (p->dir) + sizeof CVSADM_CIPROG + 10);
sprintf (fname, "%s/%s", p->dir, CVSADM_CIPROG);
f = open_file (fname, "w");
if (fprintf (f, "%s\n", p->name) < 0)
@@ -1817,10 +2342,12 @@ do_deferred_progs ()
q = p->next;
free (p);
p = q;
+ free (fname);
}
checkin_progs = NULL;
- for (p = update_progs; p != NULL; p = p->next)
+ for (p = update_progs; p != NULL; )
{
+ fname = xmalloc (strlen (p->dir) + sizeof CVSADM_UPROG + 10);
sprintf (fname, "%s/%s", p->dir, CVSADM_UPROG);
f = open_file (fname, "w");
if (fprintf (f, "%s\n", p->name) < 0)
@@ -1829,50 +2356,14 @@ do_deferred_progs ()
error (1, errno, "closing %s", fname);
free (p->name);
free (p->dir);
+ q = p->next;
free (p);
+ p = q;
+ free (fname);
}
update_progs = NULL;
}
-static int client_isemptydir PROTO((char *));
-
-/*
- * Returns 1 if the argument directory exists and is completely empty,
- * other than the existence of the CVS directory entry. Zero otherwise.
- */
-static int
-client_isemptydir (dir)
- char *dir;
-{
- DIR *dirp;
- struct dirent *dp;
-
- if ((dirp = opendir (dir)) == NULL)
- {
- if (! existence_error (errno))
- error (0, errno, "cannot open directory %s for empty check", dir);
- return (0);
- }
- errno = 0;
- while ((dp = readdir (dirp)) != NULL)
- {
- if (strcmp (dp->d_name, ".") != 0 && strcmp (dp->d_name, "..") != 0 &&
- strcmp (dp->d_name, CVSADM) != 0)
- {
- (void) closedir (dirp);
- return (0);
- }
- }
- if (errno != 0)
- {
- error (0, errno, "cannot read directory %s", dir);
- (void) closedir (dirp);
- return (0);
- }
- (void) closedir (dirp);
- return (1);
-}
-
struct save_dir {
char *dir;
struct save_dir *next;
@@ -1886,7 +2377,9 @@ add_prune_candidate (dir)
{
struct save_dir *p;
- if (dir[0] == '.' && dir[1] == '\0')
+ if ((dir[0] == '.' && dir[1] == '\0')
+ || (prune_candidates != NULL
+ && strcmp (dir, prune_candidates->dir) == 0))
return;
p = (struct save_dir *) xmalloc (sizeof (struct save_dir));
p->dir = xstrdup (dir);
@@ -1902,22 +2395,34 @@ process_prune_candidates ()
struct save_dir *p;
struct save_dir *q;
- if (toplevel_wd[0] != '\0')
- {
- if (chdir (toplevel_wd) < 0)
- error (1, errno, "could not chdir to %s", toplevel_wd);
- }
+ if (toplevel_wd != NULL)
+ {
+ if (CVS_CHDIR (toplevel_wd) < 0)
+ error (1, errno, "could not chdir to %s", toplevel_wd);
+ }
for (p = prune_candidates; p != NULL; )
{
- if (client_isemptydir (p->dir))
+ if (isemptydir (p->dir, 1))
{
- unlink_file_dir (p->dir);
+ char *b;
+
+ if (unlink_file_dir (p->dir) < 0)
+ error (0, errno, "cannot remove %s", p->dir);
+ b = strrchr (p->dir, '/');
+ if (b == NULL)
+ Subdir_Deregister ((List *) NULL, (char *) NULL, p->dir);
+ else
+ {
+ *b = '\0';
+ Subdir_Deregister ((List *) NULL, p->dir, b + 1);
+ }
}
free (p->dir);
q = p->next;
free (p);
p = q;
}
+ prune_candidates = NULL;
}
/* Send a Repository line. */
@@ -1972,23 +2477,33 @@ send_repository (dir, repos, update_dir)
/* 80 is large enough for any of CVSADM_*. */
adm_name = xmalloc (strlen (dir) + 80);
- if (use_directory == -1)
- use_directory = supported_request ("Directory");
-
- if (use_directory)
- {
- send_to_server ("Directory ", 0);
- send_to_server (update_dir, 0);
- send_to_server ("\012", 1);
- send_to_server (repos, 0);
- send_to_server ("\012", 1);
- }
- else
+ send_to_server ("Directory ", 0);
{
- send_to_server ("Repository ", 0);
- send_to_server (repos, 0);
- send_to_server ("\012", 1);
+ /* Send the directory name. I know that this
+ sort of duplicates code elsewhere, but each
+ case seems slightly different... */
+ char buf[1];
+ char *p = update_dir;
+ while (*p != '\0')
+ {
+ assert (*p != '\012');
+ if (ISDIRSEP (*p))
+ {
+ buf[0] = '/';
+ send_to_server (buf, 1);
+ }
+ else
+ {
+ buf[0] = *p;
+ send_to_server (buf, 1);
+ }
+ ++p;
+ }
}
+ send_to_server ("\012", 1);
+ send_to_server (repos, 0);
+ send_to_server ("\012", 1);
+
if (supported_request ("Static-directory"))
{
adm_name[0] = '\0';
@@ -2011,7 +2526,7 @@ send_repository (dir, repos, update_dir)
else
sprintf (adm_name, "%s/%s", dir, CVSADM_TAG);
- f = fopen (adm_name, "r");
+ f = CVS_FOPEN (adm_name, "r");
if (f == NULL)
{
if (! existence_error (errno))
@@ -2020,7 +2535,7 @@ send_repository (dir, repos, update_dir)
else
{
char line[80];
- char *nl;
+ char *nl = NULL;
send_to_server ("Sticky ", 0);
while (fgets (line, sizeof (line), f) != NULL)
{
@@ -2043,7 +2558,7 @@ send_repository (dir, repos, update_dir)
else
sprintf (adm_name, "%s/%s", dir, CVSADM_CIPROG);
- f = fopen (adm_name, "r");
+ f = CVS_FOPEN (adm_name, "r");
if (f == NULL)
{
if (! existence_error (errno))
@@ -2052,7 +2567,7 @@ send_repository (dir, repos, update_dir)
else
{
char line[80];
- char *nl;
+ char *nl = NULL;
send_to_server ("Checkin-prog ", 0);
@@ -2078,7 +2593,7 @@ send_repository (dir, repos, update_dir)
else
sprintf (adm_name, "%s/%s", dir, CVSADM_UPROG);
- f = fopen (adm_name, "r");
+ f = CVS_FOPEN (adm_name, "r");
if (f == NULL)
{
if (! existence_error (errno))
@@ -2087,7 +2602,7 @@ send_repository (dir, repos, update_dir)
else
{
char line[80];
- char *nl;
+ char *nl = NULL;
send_to_server ("Update-prog ", 0);
@@ -2243,7 +2758,7 @@ client_expand_modules (argc, argv, local)
for (i = 0; i < argc; ++i)
send_arg (argv[i]);
- send_a_repository ("", server_cvsroot, "");
+ send_a_repository ("", CVSroot_directory, "");
send_to_server ("expand-modules\012", 0);
@@ -2259,8 +2774,10 @@ client_expand_modules (argc, argv, local)
}
void
-client_send_expansions (local)
- int local;
+client_send_expansions (local, where, build_dirs)
+ int local;
+ char *where;
+ int build_dirs;
{
int i;
char *argv[1];
@@ -2275,17 +2792,17 @@ client_send_expansions (local)
for (i = 0; i < modules_count; ++i)
{
- argv[0] = modules_vector[i];
+ argv[0] = where ? where : modules_vector[i];
if (isfile (argv[0]))
- send_files (1, argv, local, 0);
+ send_files (1, argv, local, 0, build_dirs ? SEND_BUILD_DIRS : 0);
}
- send_a_repository ("", server_cvsroot, "");
+ send_a_repository ("", CVSroot_directory, "");
}
void
client_nonexpanded_setup ()
{
- send_a_repository ("", server_cvsroot, "");
+ send_a_repository ("", CVSroot_directory, "");
}
static void
@@ -2293,8 +2810,13 @@ handle_m (args, len)
char *args;
int len;
{
- fwrite (args, len, sizeof (*args), stdout);
- putc ('\n', stdout);
+ /* In the case where stdout and stderr point to the same place,
+ fflushing stderr will make output happen in the correct order.
+ Often stderr will be line-buffered and this won't be needed,
+ but not always. */
+ fflush (stderr);
+ fwrite (args, len, sizeof (*args), stdout);
+ putc ('\n', stdout);
}
static void
@@ -2302,8 +2824,20 @@ handle_e (args, len)
char *args;
int len;
{
- fwrite (args, len, sizeof (*args), stderr);
- putc ('\n', stderr);
+ /* In the case where stdout and stderr point to the same place,
+ fflushing stdout will make output happen in the correct order. */
+ fflush (stdout);
+ fwrite (args, len, sizeof (*args), stderr);
+ putc ('\n', stderr);
+}
+
+/*ARGSUSED*/
+static void
+handle_f (args, len)
+ char *args;
+ int len;
+{
+ fflush (stderr);
}
#endif /* CLIENT_SUPPORT */
@@ -2328,8 +2862,12 @@ struct response responses[] =
RSP_LINE("Checksum", handle_checksum, response_type_normal, rs_optional),
RSP_LINE("Copy-file", handle_copy_file, response_type_normal, rs_optional),
RSP_LINE("Updated", handle_updated, response_type_normal, rs_essential),
+ RSP_LINE("Created", handle_created, response_type_normal, rs_optional),
+ RSP_LINE("Update-existing", handle_update_existing, response_type_normal,
+ rs_optional),
RSP_LINE("Merged", handle_merged, response_type_normal, rs_essential),
RSP_LINE("Patched", handle_patched, response_type_normal, rs_optional),
+ RSP_LINE("Rcs-diff", handle_rcs_diff, response_type_normal, rs_optional),
RSP_LINE("Mode", handle_mode, response_type_normal, rs_optional),
RSP_LINE("Removed", handle_removed, response_type_normal, rs_essential),
RSP_LINE("Remove-entry", handle_remove_entry, response_type_normal,
@@ -2355,6 +2893,7 @@ struct response responses[] =
rs_optional),
RSP_LINE("M", handle_m, response_type_normal, rs_essential),
RSP_LINE("E", handle_e, response_type_normal, rs_essential),
+ RSP_LINE("F", handle_f, response_type_normal, rs_optional),
/* Possibly should be response_type_error. */
RSP_LINE(NULL, NULL, response_type_normal, rs_essential)
@@ -2375,91 +2914,52 @@ send_to_server (str, len)
char *str;
size_t len;
{
- if (len == 0)
- len = strlen (str);
-
-#ifdef NO_SOCKET_TO_FD
- if (use_socket_style)
- {
- int just_wrtn = 0;
- size_t wrtn = 0;
-
-#ifdef VMS
- /* send() blocks under VMS */
- if (send (server_sock, str + wrtn, len - wrtn, 0) < 0)
- error (1, errno, "writing to server socket");
-#else /* VMS */
- while (wrtn < len)
- {
- just_wrtn = send (server_sock, str + wrtn, len - wrtn, 0);
+ static int nbytes;
- if (just_wrtn == -1)
- error (1, errno, "writing to server socket");
-
- wrtn += just_wrtn;
- if (wrtn == len)
- break;
- }
-#endif /* VMS */
- }
- else
-#endif /* NO_SOCKET_TO_FD */
- {
- size_t wrtn = 0;
+ if (len == 0)
+ len = strlen (str);
+
+ buf_output (to_server, str, len);
- while (wrtn < len)
- {
- wrtn += fwrite (str + wrtn, 1, len - wrtn, to_server);
-
- if (wrtn == len)
- break;
-
- if (ferror (to_server))
- error (1, errno, "writing to server");
- if (feof (to_server))
- error (1, 0, "premature end-of-file on server");
- }
+ /* There is no reason not to send data to the server, so do it
+ whenever we've accumulated enough information in the buffer to
+ make it worth sending. */
+ nbytes += len;
+ if (nbytes >= 2 * BUFFER_DATA_SIZE)
+ {
+ int status;
+
+ status = buf_send_output (to_server);
+ if (status != 0)
+ error (1, status, "error writing to server");
+ nbytes = 0;
}
-
- if (to_server_logfile)
- if (fwrite (str, 1, len, to_server_logfile) < len)
- error (0, errno, "writing to to-server logfile");
}
-/* Read up to LEN bytes from the server. Returns actual number of bytes
- read. Gives a fatal error on EOF or error. */
+/* Read up to LEN bytes from the server. Returns actual number of
+ bytes read, which will always be at least one; blocks if there is
+ no data available at all. Gives a fatal error on EOF or error. */
static size_t
try_read_from_server (buf, len)
char *buf;
size_t len;
{
- int nread;
+ int status, nread;
+ char *data;
-#ifdef NO_SOCKET_TO_FD
- if (use_socket_style)
+ status = buf_read_data (from_server, len, &data, &nread);
+ if (status != 0)
{
- nread = recv (server_sock, buf, len, 0);
- if (nread == -1)
- error (1, errno, "reading from server");
- }
- else
-#endif
- {
- nread = fread (buf, 1, len, from_server);
- if (ferror (from_server))
- error (1, errno, "reading from server");
- if (feof (from_server))
+ if (status == -1)
error (1, 0,
"end of file from server (consult above messages if any)");
+ else if (status == -2)
+ error (1, 0, "out of memory");
+ else
+ error (1, status, "reading from server");
}
- /* Log, if that's what we're doing. */
- if (from_server_logfile != NULL && nread > 0)
- {
- size_t towrite = nread;
- if (fwrite (buf, 1, towrite, from_server_logfile) < towrite)
- error (0, errno, "writing to from-server logfile");
- }
+ memcpy (buf, data, nread);
return nread;
}
@@ -2493,7 +2993,7 @@ get_server_responses ()
char *cmd;
int len;
- len = read_line (&cmd, 0);
+ len = read_line (&cmd);
for (rs = responses; rs->name != NULL; ++rs)
if (strncmp (cmd, rs->name, strlen (rs->name)) == 0)
{
@@ -2539,120 +3039,160 @@ int
get_responses_and_close ()
{
int errs = get_server_responses ();
+ int status;
+
+ if (last_entries != NULL)
+ {
+ Entries_Close (last_entries);
+ last_entries = NULL;
+ }
do_deferred_progs ();
if (client_prune_dirs)
process_prune_candidates ();
+ /* The calls to buf_shutdown are currently only meaningful when we
+ are using compression. First we shut down TO_SERVER. That
+ tells the server that its input is finished. It then shuts
+ down the buffer it is sending to us, at which point our shut
+ down of FROM_SERVER will complete. */
+
+ status = buf_shutdown (to_server);
+ if (status != 0)
+ error (0, status, "shutting down buffer to server");
+ status = buf_shutdown (from_server);
+ if (status != 0)
+ error (0, status, "shutting down buffer from server");
+
#ifdef NO_SOCKET_TO_FD
if (use_socket_style)
- {
- if (shutdown (server_sock, 2) < 0)
- error (1, errno, "shutting down server socket");
- }
+ {
+ if (shutdown (server_sock, 2) < 0)
+ error (1, 0, "shutting down server socket: %s", SOCK_STRERROR (SOCK_ERRNO));
+ }
else
#endif /* NO_SOCKET_TO_FD */
- {
-#if defined(HAVE_KERBEROS) || defined(USE_DIRECT_TCP) || defined(AUTH_CLIENT_SUPPORT)
- if (server_fd != -1)
- {
- if (shutdown (server_fd, 1) < 0)
- error (1, errno, "shutting down connection to %s", server_host);
+ {
+#if defined(HAVE_KERBEROS) || defined(AUTH_CLIENT_SUPPORT)
+ if (server_fd != -1)
+ {
+ if (shutdown (server_fd, 1) < 0)
+ error (1, 0, "shutting down connection to %s: %s",
+ CVSroot_hostname, SOCK_STRERROR (SOCK_ERRNO));
/*
* This test will always be true because we dup the descriptor
*/
- if (fileno (from_server) != fileno (to_server))
- {
- if (fclose (to_server) != 0)
- error (1, errno,
- "closing down connection to %s",
- server_host);
- }
- }
+ if (fileno (from_server_fp) != fileno (to_server_fp))
+ {
+ if (fclose (to_server_fp) != 0)
+ error (1, errno,
+ "closing down connection to %s",
+ CVSroot_hostname);
+ }
+ }
else
-#endif /* HAVE_KERBEROS || USE_DIRECT_TCP || AUTH_CLIENT_SUPPORT */
+#endif
#ifdef SHUTDOWN_SERVER
- SHUTDOWN_SERVER (fileno (to_server));
+ SHUTDOWN_SERVER (fileno (to_server_fp));
#else /* ! SHUTDOWN_SERVER */
- {
-
+ {
+
#ifdef START_RSH_WITH_POPEN_RW
- if (pclose (to_server) == EOF)
+ if (pclose (to_server_fp) == EOF)
#else /* ! START_RSH_WITH_POPEN_RW */
- if (fclose (to_server) == EOF)
+ if (fclose (to_server_fp) == EOF)
#endif /* START_RSH_WITH_POPEN_RW */
- {
- error (1, errno, "closing connection to %s", server_host);
- }
+ {
+ error (1, errno, "closing connection to %s",
+ CVSroot_hostname);
+ }
}
- if (getc (from_server) != EOF)
- error (0, 0, "dying gasps from %s unexpected", server_host);
- else if (ferror (from_server))
- error (0, errno, "reading from %s", server_host);
-
- fclose (from_server);
+ if (! buf_empty_p (from_server)
+ || getc (from_server_fp) != EOF)
+ error (0, 0, "dying gasps from %s unexpected", CVSroot_hostname);
+ else if (ferror (from_server_fp))
+ error (0, errno, "reading from %s", CVSroot_hostname);
+
+ fclose (from_server_fp);
#endif /* SHUTDOWN_SERVER */
- }
-
-#if ! RSH_NOT_TRANSPARENT
+ }
+
if (rsh_pid != -1
&& waitpid (rsh_pid, (int *) 0, 0) == -1)
error (1, errno, "waiting for process %d", rsh_pid);
-#endif /* ! RSH_NOT_TRANSPARENT */
server_started = 0;
+ /* see if we need to sleep before returning */
+ if (last_register_time)
+ {
+ time_t now;
+
+ (void) time (&now);
+ if (now == last_register_time)
+ sleep (1); /* to avoid time-stamp races */
+ }
+
return errs;
}
-#ifndef RSH_NOT_TRANSPARENT
static void start_rsh_server PROTO((int *, int *));
-#endif /* RSH_NOT_TRANSPARENT */
int
supported_request (name)
- char *name;
+ char *name;
{
- struct request *rq;
-
- for (rq = requests; rq->name; rq++)
- if (!strcmp (rq->name, name))
- return rq->status == rq_supported;
- error (1, 0, "internal error: testing support for unknown option?");
- /* NOTREACHED */
- return 0;
+ struct request *rq;
+
+ for (rq = requests; rq->name; rq++)
+ if (!strcmp (rq->name, name))
+ return rq->status == rq_supported;
+ error (1, 0, "internal error: testing support for unknown option?");
+ /* NOTREACHED */
+ return 0;
}
#ifdef AUTH_CLIENT_SUPPORT
-void
+static void init_sockaddr PROTO ((struct sockaddr_in *, char *,
+ unsigned int));
+
+static void
init_sockaddr (name, hostname, port)
struct sockaddr_in *name;
- const char *hostname;
- unsigned short int port;
+ char *hostname;
+ unsigned int port;
{
struct hostent *hostinfo;
+ unsigned short shortport = port;
memset (name, 0, sizeof (*name));
name->sin_family = AF_INET;
- name->sin_port = htons (port);
+ name->sin_port = htons (shortport);
hostinfo = gethostbyname (hostname);
if (hostinfo == NULL)
{
fprintf (stderr, "Unknown host %s.\n", hostname);
- exit (EXIT_FAILURE);
+ error_exit ();
}
name->sin_addr = *(struct in_addr *) hostinfo->h_addr;
}
-int
+static int auth_server_port_number PROTO ((void));
+
+static int
auth_server_port_number ()
{
- return CVS_AUTH_PORT;
+ struct servent *s = getservbyname ("cvspserver", "tcp");
+
+ if (s)
+ return ntohs (s->s_port);
+ else
+ return CVS_AUTH_PORT;
}
@@ -2679,29 +3219,34 @@ connect_to_pserver (tofdp, fromfdp, verify_only)
int port_number;
struct sockaddr_in client_sai;
- /* Does nothing if already called before now. */
- parse_cvsroot ();
-
sock = socket (AF_INET, SOCK_STREAM, 0);
if (sock == -1)
{
fprintf (stderr, "socket() failed\n");
- exit (EXIT_FAILURE);
+ error_exit ();
}
port_number = auth_server_port_number ();
- init_sockaddr (&client_sai, server_host, port_number);
+ init_sockaddr (&client_sai, CVSroot_hostname, port_number);
if (connect (sock, (struct sockaddr *) &client_sai, sizeof (client_sai))
< 0)
- error (1, errno, "connect to %s:%d failed", server_host,
- CVS_AUTH_PORT);
+ error (1, 0, "connect to %s:%d failed: %s", CVSroot_hostname,
+ port_number, SOCK_STRERROR (SOCK_ERRNO));
/* Run the authorization mini-protocol before anything else. */
{
int i;
- char ch, read_buf[PATH_MAX];
+ char ch;
+
+ /* Long enough to hold I LOVE YOU or I HATE YOU. Using a fixed-size
+ buffer seems better than letting an apeshit server chew up our
+ memory with illegal responses, and the value comes from
+ the protocol itself; it is not an arbitrary limit on data sent. */
+#define LARGEST_RESPONSE 80
+ char read_buf[LARGEST_RESPONSE];
+
char *begin = NULL;
- char *repository = server_cvsroot;
- char *username = server_user;
+ char *repository = CVSroot_directory;
+ char *username = CVSroot_username;
char *password = NULL;
char *end = NULL;
@@ -2717,7 +3262,7 @@ connect_to_pserver (tofdp, fromfdp, verify_only)
}
/* Get the password, probably from ~/.cvspass. */
- password = get_cvs_password (server_user, server_host, server_cvsroot);
+ password = get_cvs_password ();
/* Announce that we're starting the authorization protocol. */
send (sock, begin, strlen (begin), 0);
@@ -2747,11 +3292,12 @@ connect_to_pserver (tofdp, fromfdp, verify_only)
* end of both ACK and NACK, and we loop, reading until "\n".
*/
ch = 0;
- memset (read_buf, 0, PATH_MAX);
- for (i = 0; (i < (PATH_MAX - 1)) && (ch != '\n'); i++)
+ memset (read_buf, 0, LARGEST_RESPONSE);
+ for (i = 0; (i < (LARGEST_RESPONSE - 1)) && (ch != '\n'); i++)
{
if (recv (sock, &ch, 1, 0) < 0)
- error (1, errno, "recv() from server %s", server_host);
+ error (1, 0, "recv() from server %s: %s", CVSroot_hostname,
+ SOCK_STRERROR (SOCK_ERRNO));
read_buf[i] = ch;
}
@@ -2763,9 +3309,10 @@ connect_to_pserver (tofdp, fromfdp, verify_only)
{
error (0, 0,
"authorization failed: server %s rejected access",
- server_host);
- error (1, errno,
- "shutdown() failed (server %s)", server_host);
+ CVSroot_hostname);
+ error (1, 0,
+ "shutdown() failed (server %s): %s", CVSroot_hostname,
+ SOCK_STRERROR (SOCK_ERRNO));
}
if (verify_only)
@@ -2773,7 +3320,7 @@ connect_to_pserver (tofdp, fromfdp, verify_only)
else
error (1, 0,
"authorization failed: server %s rejected access",
- server_host);
+ CVSroot_hostname);
}
else if (strcmp (read_buf, "I LOVE YOU\n") != 0)
{
@@ -2782,19 +3329,22 @@ connect_to_pserver (tofdp, fromfdp, verify_only)
{
error (0, 0,
"unrecognized auth response from %s: %s",
- server_host, read_buf);
- error (1, errno, "shutdown() failed, server %s", server_host);
+ CVSroot_hostname, read_buf);
+ error (1, 0,
+ "shutdown() failed, server %s: %s", CVSroot_hostname,
+ SOCK_STRERROR (SOCK_ERRNO));
}
error (1, 0,
"unrecognized auth response from %s: %s",
- server_host, read_buf);
+ CVSroot_hostname, read_buf);
}
}
if (verify_only)
{
if (shutdown (sock, 2) < 0)
- error (0, errno, "shutdown() failed, server %s", server_host);
+ error (0, 0, "shutdown() failed, server %s: %s", CVSroot_hostname,
+ SOCK_STRERROR (SOCK_ERRNO));
return 1;
}
else
@@ -2820,158 +3370,154 @@ connect_to_pserver (tofdp, fromfdp, verify_only)
#endif /* AUTH_CLIENT_SUPPORT */
-#if HAVE_KERBEROS || USE_DIRECT_TCP
+#if HAVE_KERBEROS
/*
* FIXME: this function has not been changed to deal with
* NO_SOCKET_TO_FD (i.e., systems on which sockets cannot be converted
- * to file descriptors. The first person to try building a kerberos
- * client on such a system (OS/2, Windows 95, and maybe others) will
- * have to make take care of this.
+ * to file descriptors) or with SOCK_ERRNO/SOCK_STRERROR. The first
+ * person to try building a kerberos client on such a system (OS/2,
+ * Windows 95, and maybe others) will have to make take care of this.
*/
void
start_tcp_server (tofdp, fromfdp)
- int *tofdp, *fromfdp;
+ int *tofdp, *fromfdp;
{
- int tofd, fromfd;
-
- struct hostent *hp;
- char *hname;
- const char *portenv;
- int port;
- struct sockaddr_in sin;
- int s;
+ int tofd = -1, fromfd;
+ struct hostent *hp;
+ char *hname;
+ const char *portenv;
+ int port;
+ struct sockaddr_in sin;
+ int s;
#if HAVE_KERBEROS
- KTEXT_ST ticket;
- const char *realm;
+ KTEXT_ST ticket;
+ const char *realm;
#endif /* HAVE_KERBEROS */
- int status;
-
- /*
- * We look up the host to give a better error message if it
- * does not exist. However, we then pass server_host to
- * krb_sendauth, rather than the canonical name, because
- * krb_sendauth is going to do its own canonicalization anyhow
- * and that lets us not worry about the static storage used by
- * gethostbyname.
- */
- hp = gethostbyname (server_host);
- if (hp == NULL)
- error (1, 0, "%s: unknown host", server_host);
- hname = xmalloc (strlen (hp->h_name) + 1);
- strcpy (hname, hp->h_name);
+ int status;
+
+ /*
+ * We look up the host to give a better error message if it
+ * does not exist. However, we then pass CVSroot_hostname to
+ * krb_sendauth, rather than the canonical name, because
+ * krb_sendauth is going to do its own canonicalization anyhow
+ * and that lets us not worry about the static storage used by
+ * gethostbyname.
+ */
+ hp = gethostbyname (CVSroot_hostname);
+ if (hp == NULL)
+ error (1, 0, "%s: unknown host", CVSroot_hostname);
+ hname = xmalloc (strlen (hp->h_name) + 1);
+ strcpy (hname, hp->h_name);
#if HAVE_KERBEROS
- realm = krb_realmofhost (hname);
+ realm = krb_realmofhost (hname);
#endif /* HAVE_KERBEROS */
-
- /* Get CVS_CLIENT_PORT or look up cvs/tcp with CVS_PORT as default */
- portenv = getenv ("CVS_CLIENT_PORT");
- if (portenv != NULL)
+
+ /* Get CVS_CLIENT_PORT or look up cvs/tcp with CVS_PORT as default */
+ portenv = getenv ("CVS_CLIENT_PORT");
+ if (portenv != NULL)
{
- port = atoi (portenv);
- if (port <= 0)
- goto try_rsh_no_message;
- if (trace)
- fprintf(stderr, "Using TCP port %d to contact server.\n", port);
- port = htons (port);
+ port = atoi (portenv);
+ if (port <= 0)
+ {
+ error (0, 0, "CVS_CLIENT_PORT must be a positive number! If you");
+ error (0, 0, "are trying to force a connection via rsh, please");
+ error (0, 0, "put \":server:\" at the beginning of your CVSROOT");
+ error (1, 0, "variable.");
+ }
+ if (trace)
+ fprintf(stderr, "Using TCP port %d to contact server.\n", port);
+ port = htons (port);
}
- else
+ else
{
- struct servent *sp;
-
- sp = getservbyname ("cvs", "tcp");
- if (sp == NULL)
- port = htons (CVS_PORT);
- else
- port = sp->s_port;
+ struct servent *sp;
+
+ sp = getservbyname ("cvs", "tcp");
+ if (sp == NULL)
+ port = htons (CVS_PORT);
+ else
+ port = sp->s_port;
}
-
- s = socket (AF_INET, SOCK_STREAM, 0);
- if (s < 0)
- error (1, errno, "socket");
-
- memset (&sin, 0, sizeof sin);
- sin.sin_family = AF_INET;
- sin.sin_addr.s_addr = INADDR_ANY;
- sin.sin_port = 0;
-
- if (bind (s, (struct sockaddr *) &sin, sizeof sin) < 0)
- error (1, errno, "bind");
-
- memcpy (&sin.sin_addr, hp->h_addr, hp->h_length);
- sin.sin_port = port;
-
- tofd = -1;
- if (connect (s, (struct sockaddr *) &sin, sizeof sin) < 0)
+
+ s = socket (AF_INET, SOCK_STREAM, 0);
+ if (s < 0)
+ error (1, errno, "socket");
+
+ memset (&sin, 0, sizeof sin);
+ sin.sin_family = AF_INET;
+ sin.sin_addr.s_addr = INADDR_ANY;
+ sin.sin_port = 0;
+
+ if (bind (s, (struct sockaddr *) &sin, sizeof sin) < 0)
+ error (1, errno, "bind");
+
+ memcpy (&sin.sin_addr, hp->h_addr, hp->h_length);
+ sin.sin_port = port;
+
+ if (connect (s, (struct sockaddr *) &sin, sizeof sin) < 0)
{
- error (0, errno, "connect");
- close (s);
+ error (0, errno, "connect");
+ close (s);
}
- else
+ else
{
#ifdef HAVE_KERBEROS
- struct sockaddr_in laddr;
- int laddrlen;
- MSG_DAT msg_data;
- CREDENTIALS cred;
- Key_schedule sched;
-
- laddrlen = sizeof (laddr);
- if (getsockname (s, (struct sockaddr *) &laddr, &laddrlen) < 0)
- error (1, errno, "getsockname");
-
- /* We don't care about the checksum, and pass it as zero. */
- status = krb_sendauth (KOPT_DO_MUTUAL, s, &ticket, "rcmd",
- hname, realm, (unsigned long) 0, &msg_data,
- &cred, sched, &laddr, &sin, "KCVSV1.0");
- if (status != KSUCCESS)
+ struct sockaddr_in laddr;
+ int laddrlen;
+ MSG_DAT msg_data;
+ CREDENTIALS cred;
+
+ laddrlen = sizeof (laddr);
+ if (getsockname (s, (struct sockaddr *) &laddr, &laddrlen) < 0)
+ error (1, errno, "getsockname");
+
+ /* We don't care about the checksum, and pass it as zero. */
+ status = krb_sendauth (KOPT_DO_MUTUAL, s, &ticket, "rcmd",
+ hname, realm, (unsigned long) 0, &msg_data,
+ &cred, sched, &laddr, &sin, "KCVSV1.0");
+ if (status != KSUCCESS)
{
- error (0, 0, "kerberos: %s", krb_get_err_text(status));
- close (s);
+ error (0, 0, "kerberos: %s", krb_get_err_text(status));
+ close (s);
}
- else
+ else
{
+ memcpy (kblock, cred.session, sizeof (C_Block));
+
#endif /* HAVE_KERBEROS */
- server_fd = s;
- close_on_exec (server_fd);
- tofd = fromfd = s;
+ server_fd = s;
+ close_on_exec (server_fd);
+ tofd = fromfd = s;
#ifdef HAVE_KERBEROS
}
#endif /* HAVE_KERBEROS */
}
- if (tofd == -1)
+ if (tofd == -1)
{
- /* FIXME: Falling back like this is slow and we should probably
- just make it a fatal error (so that people use the right
- environment variables or, when we get around to implementing
- the right ones, access methods). */
- error (0, 0, "trying to start server using rsh");
- try_rsh_no_message:
- server_fd = -1;
-#if ! RSH_NOT_TRANSPARENT
- start_rsh_server (&tofd, &fromfd);
-#else /* RSH_NOT_TRANSPARENT */
-#if defined (START_SERVER)
- START_SERVER (&tofd, &fromfd, getcaller (),
- server_user, server_host, server_cvsroot);
-#endif /* defined (START_SERVER) */
-#endif /* ! RSH_NOT_TRANSPARENT */
+#ifdef HAVE_KERBEROS
+ error (0, 0, "Kerberos connect failed");
+#else
+ error (0, 0, "Direct TCP connect failed");
+#endif
+ error (1, 0, "couldn't connect to remote host %s", CVSroot_hostname);
}
- free (hname);
- /* Give caller the values it wants. */
- *tofdp = tofd;
- *fromfdp = fromfd;
+ free (hname);
+
+ /* Give caller the values it wants. */
+ *tofdp = tofd;
+ *fromfdp = fromfd;
}
-#endif /* HAVE_KERBEROS || USE_DIRECT_TCP */
+#endif /* HAVE_KERBEROS */
static int send_variable_proc PROTO ((Node *, void *));
@@ -2992,80 +3538,77 @@ send_variable_proc (node, closure)
void
start_server ()
{
- int tofd, fromfd;
- char *log = getenv ("CVS_CLIENT_LOG");
+ int tofd, fromfd;
+ char *log = getenv ("CVS_CLIENT_LOG");
- /* Note that generally speaking we do *not* fall back to a different
- way of connecting if the first one does not work. This is slow
- (*really* slow on a 14.4kbps link); the clean way to have a CVS
- which supports several ways of connecting is with access methods. */
+ /* Note that generally speaking we do *not* fall back to a different
+ way of connecting if the first one does not work. This is slow
+ (*really* slow on a 14.4kbps link); the clean way to have a CVS
+ which supports several ways of connecting is with access methods. */
- /* Init these to NULL. They will be set later if logging is on. */
- from_server_logfile = (FILE *) NULL;
- to_server_logfile = (FILE *) NULL;
+ switch (CVSroot_method)
+ {
#ifdef AUTH_CLIENT_SUPPORT
- if (use_authenticating_server)
- {
- /* Toss the return value. It will die with error if anything
- goes wrong anyway. */
- connect_to_pserver (&tofd, &fromfd, 0);
- }
- else
-#endif /* AUTH_CLIENT_SUPPORT */
- {
-#if HAVE_KERBEROS || USE_DIRECT_TCP
- start_tcp_server (&tofd, &fromfd);
-#else
+ case pserver_method:
+ /* Toss the return value. It will die with error if anything
+ goes wrong anyway. */
+ connect_to_pserver (&tofd, &fromfd, 0);
+ break;
+#endif
+
+#if HAVE_KERBEROS
+ case kserver_method:
+ start_tcp_server (&tofd, &fromfd);
+ break;
+#endif
-# if ! RSH_NOT_TRANSPARENT
- start_rsh_server (&tofd, &fromfd);
-# else
+ case ext_method:
+ start_rsh_server (&tofd, &fromfd);
+ break;
-# if defined(START_SERVER)
- START_SERVER (&tofd, &fromfd, getcaller (),
- server_user, server_host, server_cvsroot);
-# endif
+ case server_method:
+#if defined(START_SERVER)
+ START_SERVER (&tofd, &fromfd, getcaller (),
+ CVSroot_username, CVSroot_hostname,
+ CVSroot_directory);
+# if defined (START_SERVER_RETURNS_SOCKET) && defined (NO_SOCKET_TO_FD)
+ /* This is a system on which we can only write to a socket
+ using send/recv. Therefore its START_SERVER needs to
+ return a socket. */
+ use_socket_style = 1;
+ server_sock = tofd;
# endif
+
+#else
+ /* FIXME: It should be possible to implement this portably,
+ like pserver, which would get rid of the duplicated code
+ in {vms,windows-NT,...}/startserver.c. */
+ error (1, 0, "\
+the :server: access method is not supported by this port of CVS");
#endif
- }
+ break;
-#if defined(VMS) && defined(NO_SOCKET_TO_FD)
- /* Avoid mixing sockets with stdio */
- use_socket_style = 1;
- server_sock = tofd;
-#endif /* VMS && NO_SOCKET_TO_FD */
+ default:
+ error (1, 0, "\
+(start_server internal error): unknown access method");
+ break;
+ }
/* "Hi, I'm Darlene and I'll be your server tonight..." */
server_started = 1;
- /* Set up logfiles, if any. */
- if (log)
+#ifdef NO_SOCKET_TO_FD
+ if (use_socket_style)
{
- int len = strlen (log);
- char *buf = xmalloc (len + 5);
- char *p;
-
- strcpy (buf, log);
- p = buf + len;
-
- strcpy (p, ".in");
- to_server_logfile = open_file (buf, "w");
- if (to_server_logfile == NULL)
- error (0, errno, "opening to-server logfile %s", buf);
-
- strcpy (p, ".out");
- from_server_logfile = open_file (buf, "w");
- if (from_server_logfile == NULL)
- error (0, errno, "opening from-server logfile %s", buf);
-
- free (buf);
+ to_server = socket_buffer_initialize (server_sock, 0,
+ buf_memory_error);
+ from_server = socket_buffer_initialize (server_sock, 1,
+ buf_memory_error);
}
-
-#ifdef NO_SOCKET_TO_FD
- if (! use_socket_style)
+ else
#endif /* NO_SOCKET_TO_FD */
- {
+ {
/* todo: some OS's don't need these calls... */
close_on_exec (tofd);
close_on_exec (fromfd);
@@ -3081,26 +3624,65 @@ start_server ()
}
/* These will use binary mode on systems which have it. */
- to_server = fdopen (tofd, FOPEN_BINARY_WRITE);
- if (to_server == NULL)
- error (1, errno, "cannot fdopen %d for write", tofd);
- from_server = fdopen (fromfd, FOPEN_BINARY_READ);
- if (from_server == NULL)
- error (1, errno, "cannot fdopen %d for read", fromfd);
- }
+ to_server_fp = fdopen (tofd, FOPEN_BINARY_WRITE);
+ if (to_server_fp == NULL)
+ error (1, errno, "cannot fdopen %d for write", tofd);
+ to_server = stdio_buffer_initialize (to_server_fp, 0,
+ buf_memory_error);
+
+ from_server_fp = fdopen (fromfd, FOPEN_BINARY_READ);
+ if (from_server_fp == NULL)
+ error (1, errno, "cannot fdopen %d for read", fromfd);
+ from_server = stdio_buffer_initialize (from_server_fp, 1,
+ buf_memory_error);
+ }
+
+ /* Set up logfiles, if any. */
+ if (log)
+ {
+ int len = strlen (log);
+ char *buf = xmalloc (len + 5);
+ char *p;
+ FILE *fp;
+
+ strcpy (buf, log);
+ p = buf + len;
+
+ /* Open logfiles in binary mode so that they reflect
+ exactly what was transmitted and received (that is
+ more important than that they be maximally
+ convenient to view). */
+ strcpy (p, ".in");
+ fp = open_file (buf, "wb");
+ if (fp == NULL)
+ error (0, errno, "opening to-server logfile %s", buf);
+ else
+ to_server = log_buffer_initialize (to_server, fp, 0,
+ buf_memory_error);
+
+ strcpy (p, ".out");
+ fp = open_file (buf, "wb");
+ if (fp == NULL)
+ error (0, errno, "opening from-server logfile %s", buf);
+ else
+ from_server = log_buffer_initialize (from_server, fp, 1,
+ buf_memory_error);
+
+ free (buf);
+ }
/* Clear static variables. */
if (toplevel_repos != NULL)
- free (toplevel_repos);
+ free (toplevel_repos);
toplevel_repos = NULL;
if (last_dir_name != NULL)
- free (last_dir_name);
+ free (last_dir_name);
last_dir_name = NULL;
if (last_repos != NULL)
- free (last_repos);
+ free (last_repos);
last_repos = NULL;
if (last_update_dir != NULL)
- free (last_update_dir);
+ free (last_update_dir);
last_update_dir = NULL;
stored_checksum_valid = 0;
stored_mode_valid = 0;
@@ -3108,7 +3690,7 @@ start_server ()
if (strcmp (command_name, "init") != 0)
{
send_to_server ("Root ", 0);
- send_to_server (server_cvsroot, 0);
+ send_to_server (CVSroot_directory, 0);
send_to_server ("\012", 1);
}
@@ -3127,7 +3709,7 @@ start_server ()
send_to_server ("valid-requests\012", 0);
if (get_server_responses ())
- exit (EXIT_FAILURE);
+ error_exit ();
/*
* Now handle global options.
@@ -3207,9 +3789,55 @@ start_server ()
"This server does not support the global -l option.");
}
}
+ if (cvsencrypt)
+ {
+#ifdef ENCRYPTION
+ /* Turn on encryption before turning on compression. We do
+ not want to try to compress the encrypted stream. Instead,
+ we want to encrypt the compressed stream. If we can't turn
+ on encryption, bomb out; don't let the user think the data
+ is being encrypted when it is not. */
+#ifdef HAVE_KERBEROS
+ if (CVSroot_method == kserver_method)
+ {
+ if (! supported_request ("Kerberos-encrypt"))
+ error (1, 0, "This server does not support encryption");
+ send_to_server ("Kerberos-encrypt\012", 0);
+ to_server = krb_encrypt_buffer_initialize (to_server, 0, sched,
+ kblock,
+ buf_memory_error);
+ from_server = krb_encrypt_buffer_initialize (from_server, 1,
+ sched, kblock,
+ buf_memory_error);
+ }
+ else
+#endif /* HAVE_KERBEROS */
+ error (1, 0, "Encryption is only supported when using Kerberos");
+#else /* ! ENCRYPTION */
+ error (1, 0, "This client does not support encryption");
+#endif /* ! ENCRYPTION */
+ }
if (gzip_level)
{
- if (supported_request ("gzip-file-contents"))
+ if (supported_request ("Gzip-stream"))
+ {
+ char gzip_level_buf[5];
+ send_to_server ("Gzip-stream ", 0);
+ sprintf (gzip_level_buf, "%d", gzip_level);
+ send_to_server (gzip_level_buf, 0);
+ send_to_server ("\012", 1);
+
+ /* All further communication with the server will be
+ compressed. */
+
+ to_server = compress_buffer_initialize (to_server, 0, gzip_level,
+ buf_memory_error);
+ from_server = compress_buffer_initialize (from_server, 1,
+ gzip_level,
+ buf_memory_error);
+ }
+#ifndef NO_CLIENT_GZIP_PROCESS
+ else if (supported_request ("gzip-file-contents"))
{
char gzip_level_buf[5];
send_to_server ("gzip-file-contents ", 0);
@@ -3217,10 +3845,16 @@ start_server ()
send_to_server (gzip_level_buf, 0);
send_to_server ("\012", 1);
+
+ file_gzip_level = gzip_level;
}
+#endif
else
{
fprintf (stderr, "server doesn't support gzip-file-contents\n");
+ /* Setting gzip_level to 0 prevents us from giving the
+ error twice if update has to contact the server again
+ to fetch unpatchable files. */
gzip_level = 0;
}
}
@@ -3239,7 +3873,6 @@ start_server ()
walklist (variable_list, send_variable_proc, NULL);
}
-#ifndef RSH_NOT_TRANSPARENT
/* Contact the server by starting it with rsh. */
/* Right now, we have two different definitions for this function,
@@ -3258,68 +3891,81 @@ start_server ()
static void
start_rsh_server (tofdp, fromfdp)
- int *tofdp, *fromfdp;
+ int *tofdp, *fromfdp;
{
- int pipes[2];
-
- /* If you're working through firewalls, you can set the
- CVS_RSH environment variable to a script which uses rsh to
- invoke another rsh on a proxy machine. */
- char *cvs_rsh = getenv ("CVS_RSH");
- char *cvs_server = getenv ("CVS_SERVER");
- char command[PATH_MAX];
- int i = 0;
- /* This needs to fit "rsh", "-b", "-l", "USER", "host",
- "cmd (w/ args)", and NULL. We leave some room to grow. */
- char *rsh_argv[10];
-
- if (!cvs_rsh)
- cvs_rsh = "rsh";
- if (!cvs_server)
- cvs_server = "cvs";
-
- /* If you are running a very old (Nov 3, 1994, before 1.5)
- * version of the server, you need to make sure that your .bashrc
- * on the server machine does not set CVSROOT to something
- * containing a colon (or better yet, upgrade the server). */
-
- /* The command line starts out with rsh. */
- rsh_argv[i++] = cvs_rsh;
-
+ int pipes[2];
+
+ /* If you're working through firewalls, you can set the
+ CVS_RSH environment variable to a script which uses rsh to
+ invoke another rsh on a proxy machine. */
+ char *cvs_rsh = getenv ("CVS_RSH");
+ char *cvs_server = getenv ("CVS_SERVER");
+ int i = 0;
+ /* This needs to fit "rsh", "-b", "-l", "USER", "host",
+ "cmd (w/ args)", and NULL. We leave some room to grow. */
+ char *rsh_argv[10];
+
+ if (!cvs_rsh)
+ /* People sometimes suggest or assume that this should default
+ to "remsh" on systems like HPUX in which that is the
+ system-supplied name for the rsh program. However, that
+ causes various problems (keep in mind that systems such as
+ HPUX might have non-system-supplied versions of "rsh", like
+ a Kerberized one, which one might want to use). If we
+ based the name on what is found in the PATH of the person
+ who runs configure, that would make it harder to
+ consistently produce the same result in the face of
+ different people producing binary distributions. If we
+ based it on "remsh" always being the default for HPUX
+ (e.g. based on uname), that might be slightly better but
+ would require us to keep track of what the defaults are for
+ each system type, and probably would cope poorly if the
+ existence of remsh or rsh varies from OS version to OS
+ version. Therefore, it seems best to have the default
+ remain "rsh", and tell HPUX users to specify remsh, for
+ example in CVS_RSH or other such mechanisms to be devised,
+ if that is what they want (the manual already tells them
+ that). */
+ cvs_rsh = "rsh";
+ if (!cvs_server)
+ cvs_server = "cvs";
+
+ /* The command line starts out with rsh. */
+ rsh_argv[i++] = cvs_rsh;
+
#ifdef RSH_NEEDS_BINARY_FLAG
- /* "-b" for binary, under OS/2. */
- rsh_argv[i++] = "-b";
+ /* "-b" for binary, under OS/2. */
+ rsh_argv[i++] = "-b";
#endif /* RSH_NEEDS_BINARY_FLAG */
- /* Then we strcat more things on the end one by one. */
- if (server_user != NULL)
+ /* Then we strcat more things on the end one by one. */
+ if (CVSroot_username != NULL)
{
- rsh_argv[i++] = "-l";
- rsh_argv[i++] = server_user;
+ rsh_argv[i++] = "-l";
+ rsh_argv[i++] = CVSroot_username;
}
-
- rsh_argv[i++] = server_host;
- rsh_argv[i++] = cvs_server;
- rsh_argv[i++] = "server";
- /* Mark the end of the arg list. */
- rsh_argv[i] = (char *) NULL;
+ rsh_argv[i++] = CVSroot_hostname;
+ rsh_argv[i++] = cvs_server;
+ rsh_argv[i++] = "server";
+
+ /* Mark the end of the arg list. */
+ rsh_argv[i] = (char *) NULL;
- if (trace)
+ if (trace)
{
- fprintf (stderr, " -> Starting server: ");
- fprintf (stderr, "%s", command);
- putc ('\n', stderr);
+ fprintf (stderr, " -> Starting server: ");
+ putc ('\n', stderr);
}
-
- /* Do the deed. */
- rsh_pid = popenRW (rsh_argv, pipes);
- if (rsh_pid < 0)
- error (1, errno, "cannot start server via rsh");
-
- /* Give caller the file descriptors. */
- *tofdp = pipes[0];
- *fromfdp = pipes[1];
+
+ /* Do the deed. */
+ rsh_pid = popenRW (rsh_argv, pipes);
+ if (rsh_pid < 0)
+ error (1, errno, "cannot start server via rsh");
+
+ /* Give caller the file descriptors. */
+ *tofdp = pipes[0];
+ *fromfdp = pipes[1];
}
#else /* ! START_RSH_WITH_POPEN_RW */
@@ -3346,7 +3992,7 @@ start_rsh_server (tofdp, fromfdp)
versions of rsh that grab switches out of the middle of the
command (they're calling the GNU getopt routines incorrectly). */
command = xmalloc (strlen (cvs_server)
- + strlen (server_cvsroot)
+ + strlen (CVSroot_directory)
+ 50);
/* If you are running a very old (Nov 3, 1994, before 1.5)
@@ -3360,15 +4006,15 @@ start_rsh_server (tofdp, fromfdp)
char **p = argv;
*p++ = cvs_rsh;
- *p++ = server_host;
+ *p++ = CVSroot_hostname;
/* If the login names differ between client and server
* pass it on to rsh.
*/
- if (server_user != NULL)
+ if (CVSroot_username != NULL)
{
*p++ = "-l";
- *p++ = server_user;
+ *p++ = CVSroot_username;
}
*p++ = command;
@@ -3388,10 +4034,10 @@ start_rsh_server (tofdp, fromfdp)
if (rsh_pid < 0)
error (1, errno, "cannot start server via rsh");
}
+ free (command);
}
#endif /* START_RSH_WITH_POPEN_RW */
-#endif /* ! RSH_NOT_TRANSPARENT */
@@ -3423,6 +4069,10 @@ send_arg (string)
static void send_modified PROTO ((char *, char *, Vers_TS *));
+/* VERS->OPTIONS specifies whether the file is binary or not. NOTE: BEFORE
+ using any other fields of the struct vers, we would need to fix
+ client_process_import_file to set them up. */
+
static void
send_modified (file, short_pathname, vers)
char *file;
@@ -3437,8 +4087,11 @@ send_modified (file, short_pathname, vers)
int bufsize;
int bin;
+ if (trace)
+ (void) fprintf (stderr, " -> Sending file `%s' to server\n", file);
+
/* Don't think we can assume fstat exists. */
- if (stat (file, &sb) < 0)
+ if ( CVS_STAT (file, &sb) < 0)
error (1, errno, "reading %s", short_pathname);
mode_string = mode_to_string (sb.st_mode);
@@ -3459,25 +4112,43 @@ send_modified (file, short_pathname, vers)
else
bin = 0;
- fd = open (file, O_RDONLY | (bin ? OPEN_BINARY : 0));
+#ifdef BROKEN_READWRITE_CONVERSION
+ if (!bin)
+ {
+ /* If only stdio, not open/write/etc., do text/binary
+ conversion, use convert_file which can compensate
+ (FIXME: we could just use stdio instead which would
+ avoid the whole problem). */
+ char tfile[1024]; strcpy(tfile, file); strcat(tfile, ".CVSBFCTMP");
+ convert_file (file, O_RDONLY,
+ tfile, O_WRONLY | O_CREAT | O_TRUNC | OPEN_BINARY);
+ fd = CVS_OPEN (tfile, O_RDONLY | OPEN_BINARY);
+ if (fd < 0)
+ error (1, errno, "reading %s", short_pathname);
+ }
+ else
+ fd = CVS_OPEN (file, O_RDONLY | OPEN_BINARY);
+#else
+ fd = CVS_OPEN (file, O_RDONLY | (bin ? OPEN_BINARY : 0));
+#endif
if (fd < 0)
error (1, errno, "reading %s", short_pathname);
- if (gzip_level && sb.st_size > 100)
+ if (file_gzip_level && sb.st_size > 100)
{
int nread, newsize = 0, gzip_status;
pid_t gzip_pid;
char *bufp = buf;
int readsize = 8192;
#ifdef LINES_CRLF_TERMINATED
- char tempfile[L_tmpnam];
+ char *tempfile;
int converting;
#endif /* LINES_CRLF_TERMINATED */
#ifdef LINES_CRLF_TERMINATED
- /* Assume everything in a "cvs import" is text. */
if (vers == NULL)
+ /* "Can't happen". */
converting = 1;
else
/* Otherwise, we convert things unless they're binary. */
@@ -3503,7 +4174,7 @@ send_modified (file, short_pathname, vers)
if (close (fd) < 0)
error (0, errno, "warning: can't close %s", short_pathname);
- tmpnam (tempfile);
+ tempfile = cvs_temp_name ();
convert_file (file, O_RDONLY,
tempfile,
O_WRONLY | O_CREAT | O_TRUNC | OPEN_BINARY);
@@ -3513,13 +4184,13 @@ send_modified (file, short_pathname, vers)
do remember something obscure in the manuals about propagating
the translation mode to created processes via environment
variables, ick. */
- fd = open (tempfile, O_RDONLY | OPEN_BINARY);
+ fd = CVS_OPEN (tempfile, O_RDONLY | OPEN_BINARY);
if (fd < 0)
error (1, errno, "reading %s", short_pathname);
}
#endif /* LINES_CRLF_TERMINATED */
- fd = filter_through_gzip (fd, 1, gzip_level, &gzip_pid);
+ fd = filter_through_gzip (fd, 1, file_gzip_level, &gzip_pid);
/* FIXME: is there any reason to go through all this realloc'ing
when we could just be writing the data to the network as we read
@@ -3558,9 +4229,11 @@ send_modified (file, short_pathname, vers)
#if LINES_CRLF_TERMINATED
if (converting)
{
- if (unlink (tempfile) < 0)
+ if ( CVS_UNLINK (tempfile) < 0)
error (0, errno,
"warning: can't remove temp file %s", tempfile);
+ free (tempfile);
+ tempfile = NULL;
}
#endif /* LINES_CRLF_TERMINATED */
@@ -3613,48 +4286,80 @@ send_modified (file, short_pathname, vers)
sprintf (tmp, "%lu\012", (unsigned long) newsize);
send_to_server (tmp, 0);
}
+#ifdef BROKEN_READWRITE_CONVERSION
+ if (!bin)
+ {
+ char tfile[1024]; strcpy(tfile, file); strcat(tfile, ".CVSBFCTMP");
+ if (CVS_UNLINK (tfile) < 0)
+ error (0, errno, "warning: can't remove temp file %s", tfile);
+ }
+#endif
/*
* Note that this only ends with a newline if the file ended with
* one.
*/
if (newsize > 0)
- send_to_server (buf, newsize);
+ send_to_server (buf, newsize);
}
free (buf);
free (mode_string);
}
-static int send_fileproc PROTO ((struct file_info *finfo));
+/* The address of an instance of this structure is passed to
+ send_fileproc, send_filesdoneproc, and send_direntproc, as the
+ callerdat parameter. */
+
+struct send_data
+{
+ /* Each of the following flags are zero for clear or nonzero for set. */
+ int build_dirs;
+ int force;
+ int no_contents;
+};
+
+static int send_fileproc PROTO ((void *callerdat, struct file_info *finfo));
/* Deal with one file. */
static int
-send_fileproc (finfo)
+send_fileproc (callerdat, finfo)
+ void *callerdat;
struct file_info *finfo;
{
+ struct send_data *args = (struct send_data *) callerdat;
Vers_TS *vers;
+ struct file_info xfinfo;
+ /* File name to actually use. Might differ in case from
+ finfo->file. */
+ char *filename;
send_a_repository ("", finfo->repository, finfo->update_dir);
- vers = Version_TS ((char *)NULL, (char *)NULL, (char *)NULL,
- (char *)NULL,
- finfo->file, 0, 0, finfo->entries, (RCSNode *)NULL);
+ xfinfo = *finfo;
+ xfinfo.repository = NULL;
+ xfinfo.rcs = NULL;
+ vers = Version_TS (&xfinfo, NULL, NULL, NULL, 0, 0);
+
+ if (vers->entdata != NULL)
+ filename = vers->entdata->user;
+ else
+ filename = finfo->file;
if (vers->vn_user != NULL)
{
- char *tmp;
-
- tmp = xmalloc (strlen (finfo->file) + strlen (vers->vn_user)
- + strlen (vers->options) + 200);
- sprintf (tmp, "Entry /%s/%s/%s%s/%s/",
- finfo->file, vers->vn_user,
- vers->ts_conflict == NULL ? "" : "+",
- (vers->ts_conflict == NULL ? ""
- : (vers->ts_user != NULL &&
- strcmp (vers->ts_conflict, vers->ts_user) == 0
- ? "="
- : "modified")),
- vers->options);
+ char *tmp;
+
+ tmp = xmalloc (strlen (filename) + strlen (vers->vn_user)
+ + strlen (vers->options) + 200);
+ sprintf (tmp, "Entry /%s/%s/%s%s/%s/",
+ filename, vers->vn_user,
+ vers->ts_conflict == NULL ? "" : "+",
+ (vers->ts_conflict == NULL ? ""
+ : (vers->ts_user != NULL &&
+ strcmp (vers->ts_conflict, vers->ts_user) == 0
+ ? "="
+ : "modified")),
+ vers->options);
/* The Entries request. */
/* Not sure about whether this deals with -k and stuff right. */
@@ -3679,33 +4384,28 @@ send_fileproc (finfo)
* Do we want to print "file was lost" like normal CVS?
* Would it always be appropriate?
*/
- /* File no longer exists. */
- if (!use_unchanged)
- {
- /* if the server is old, use the old request... */
- send_to_server ("Lost ", 0);
- send_to_server (finfo->file, 0);
- send_to_server ("\012", 1);
- /*
- * Otherwise, don't do anything for missing files,
- * they just happen.
- */
- }
+ /* File no longer exists. Don't do anything, missing files
+ just happen. */
}
else if (vers->ts_rcs == NULL
+ || args->force
|| strcmp (vers->ts_user, vers->ts_rcs) != 0)
{
- send_modified (finfo->file, finfo->fullname, vers);
+ if (args->no_contents
+ && supported_request ("Is-modified"))
+ {
+ send_to_server ("Is-modified ", 0);
+ send_to_server (filename, 0);
+ send_to_server ("\012", 1);
+ }
+ else
+ send_modified (filename, finfo->fullname, vers);
}
else
{
- /* Only use this request if the server supports it... */
- if (use_unchanged)
- {
- send_to_server ("Unchanged ", 0);
- send_to_server (finfo->file, 0);
- send_to_server ("\012", 1);
- }
+ send_to_server ("Unchanged ", 0);
+ send_to_server (filename, 0);
+ send_to_server ("\012", 1);
}
/* if this directory has an ignore list, add this file to it */
@@ -3745,25 +4445,27 @@ send_ignproc (file, dir)
}
}
-static int send_filesdoneproc PROTO ((int, char *, char *));
+static int send_filesdoneproc PROTO ((void *, int, char *, char *, List *));
static int
-send_filesdoneproc (err, repository, update_dir)
+send_filesdoneproc (callerdat, err, repository, update_dir, entries)
+ void *callerdat;
int err;
char *repository;
char *update_dir;
+ List *entries;
{
/* if this directory has an ignore list, process it then free it */
if (ignlist)
{
- ignore_files (ignlist, update_dir, send_ignproc);
+ ignore_files (ignlist, entries, update_dir, send_ignproc);
dellist (&ignlist);
}
return (err);
}
-static Dtype send_dirent_proc PROTO ((char *, char *, char *));
+static Dtype send_dirent_proc PROTO ((void *, char *, char *, char *, List *));
/*
* send_dirent_proc () is called back by the recursion processor before a
@@ -3774,20 +4476,18 @@ static Dtype send_dirent_proc PROTO ((char *, char *, char *));
*
*/
static Dtype
-send_dirent_proc (dir, repository, update_dir)
+send_dirent_proc (callerdat, dir, repository, update_dir, entries)
+ void *callerdat;
char *dir;
char *repository;
char *update_dir;
+ List *entries;
{
+ struct send_data *args = (struct send_data *) callerdat;
int dir_exists;
+ char *cvsadm_name;
char *cvsadm_repos_name;
- /*
- * If the directory does not exist yet (e.g. "cvs update -d
- * foo"), no need to send any files from it.
- */
- dir_exists = isdir (dir);
-
if (ignore_directory (update_dir))
{
/* print the warm fuzzy message */
@@ -3796,6 +4496,19 @@ send_dirent_proc (dir, repository, update_dir)
return (R_SKIP_ALL);
}
+ /*
+ * If the directory does not exist yet (e.g. "cvs update -d foo"),
+ * no need to send any files from it. If the directory does not
+ * have a CVS directory, then we pretend that it does not exist.
+ * Otherwise, we will fail when trying to open the Entries file.
+ * This case will happen when checking out a module defined as
+ * ``-a .''.
+ */
+ cvsadm_name = xmalloc (strlen (dir) + sizeof (CVSADM) + 10);
+ sprintf (cvsadm_name, "%s/%s", dir, CVSADM);
+ dir_exists = isdir (cvsadm_name);
+ free (cvsadm_name);
+
/* initialize the ignore list for this directory */
ignlist = getlist ();
@@ -3818,7 +4531,14 @@ send_dirent_proc (dir, repository, update_dir)
free (repos);
}
else
- send_a_repository (dir, repository, update_dir);
+ {
+ /* Don't send a non-existent directory unless we are building
+ new directories (build_dirs is true). Otherwise, CVS may
+ see a D line in an Entries file, and recreate a directory
+ which the user removed by hand. */
+ if (dir_exists || args->build_dirs)
+ send_a_repository (dir, repository, update_dir);
+ }
free (cvsadm_repos_name);
return (dir_exists ? R_PROCESS : R_SKIP_ALL);
@@ -3826,27 +4546,35 @@ send_dirent_proc (dir, repository, update_dir)
/*
* Send each option in a string to the server, one by one.
- * This assumes that the options are single characters. For
- * more complex parsing, do it yourself.
+ * This assumes that the options are separated by spaces, for example
+ * STRING might be "--foo -C5 -y".
*/
void
send_option_string (string)
char *string;
{
+ char *copy;
char *p;
- char it[3];
-
- for (p = string; p[0]; p++) {
- if (p[0] == ' ')
- continue;
- if (p[0] == '-')
- continue;
- it[0] = '-';
- it[1] = p[0];
- it[2] = '\0';
- send_arg (it);
+
+ copy = xstrdup (string);
+ p = copy;
+ while (1)
+ {
+ char *s;
+ char l;
+
+ for (s = p; *s != ' ' && *s != '\0'; s++)
+ ;
+ l = *s;
+ *s = '\0';
+ if (s != p)
+ send_arg (p);
+ if (l == '\0')
+ break;
+ p = s + 1;
}
+ free (copy);
}
@@ -3859,8 +4587,6 @@ send_file_names (argc, argv, flags)
unsigned int flags;
{
int i;
- char *p;
- char *q;
int level;
int max_level;
@@ -3873,25 +4599,9 @@ send_file_names (argc, argv, flags)
max_level = 0;
for (i = 0; i < argc; ++i)
{
- p = argv[i];
- level = 0;
- do
- {
- q = strchr (p, '/');
- if (q != NULL)
- ++q;
- if (p[0] == '.' && p[1] == '.' && (p[2] == '\0' || p[2] == '/'))
- {
- --level;
- if (-level > max_level)
- max_level = -level;
- }
- else if (p[0] == '.' && (p[1] == '\0' || p[1] == '/'))
- ;
- else
- ++level;
- p = q;
- } while (p != NULL);
+ level = pathname_levels (argv[i]);
+ if (level > max_level)
+ max_level = level;
}
if (max_level > 0)
{
@@ -3918,6 +4628,46 @@ send_file_names (argc, argv, flags)
{
char buf[1];
char *p = argv[i];
+ char *line = NULL;
+
+#ifdef FILENAMES_CASE_INSENSITIVE
+ /* We want to send the file name as it appears
+ in CVS/Entries. We put this inside an ifdef
+ to avoid doing all these system calls in
+ cases where fncmp is just strcmp anyway. */
+ /* For now just do this for files in the local
+ directory. Would be nice to handle the
+ non-local case too, though. */
+ /* The isdir check could more gracefully be replaced
+ with a way of having Entries_Open report back the
+ error to us and letting us ignore existence_error.
+ Or some such. */
+ if (p == last_component (p) && isdir (CVSADM))
+ {
+ List *entries;
+ Node *node;
+
+ /* If we were doing non-local directory,
+ we would save_cwd, CVS_CHDIR
+ like in update.c:isemptydir. */
+ /* Note that if we are adding a directory,
+ the following will read the entry
+ that we just wrote there, that is, we
+ will get the case specified on the
+ command line, not the case of the
+ directory in the filesystem. This
+ is correct behavior. */
+ entries = Entries_Open (0);
+ node = findnode_fn (entries, p);
+ if (node != NULL)
+ {
+ line = xstrdup (node->key);
+ p = line;
+ delnode (node);
+ }
+ Entries_Close (entries);
+ }
+#endif /* FILENAMES_CASE_INSENSITIVE */
send_to_server ("Argument ", 0);
@@ -3940,6 +4690,8 @@ send_file_names (argc, argv, flags)
++p;
}
send_to_server ("\012", 1);
+ if (line != NULL)
+ free (line);
}
if (flags & SEND_EXPAND_WILD)
@@ -3952,20 +4704,24 @@ send_file_names (argc, argv, flags)
}
-/*
- * Send Repository, Modified and Entry. argc and argv contain only
- * the files to operate on (or empty for everything), not options.
- * local is nonzero if we should not recurse (-l option). Also sends
- * Argument lines for argc and argv, so should be called after options
- * are sent.
- */
+/* Send Repository, Modified and Entry. argc and argv contain only
+ the files to operate on (or empty for everything), not options.
+ local is nonzero if we should not recurse (-l option). flags &
+ SEND_BUILD_DIRS is nonzero if nonexistent directories should be
+ sent. flags & SEND_FORCE is nonzero if we should send unmodified
+ files to the server as though they were modified. flags &
+ SEND_NO_CONTENTS means that this command only needs to know
+ _whether_ a file is modified, not the contents. Also sends Argument
+ lines for argc and argv, so should be called after options are sent. */
void
-send_files (argc, argv, local, aflag)
+send_files (argc, argv, local, aflag, flags)
int argc;
char **argv;
int local;
int aflag;
+ unsigned int flags;
{
+ struct send_data args;
int err;
/*
@@ -3973,12 +4729,15 @@ send_files (argc, argv, local, aflag)
* But we don't actually use it, so I don't think it matters what we pass
* for aflag here.
*/
+ args.build_dirs = flags & SEND_BUILD_DIRS;
+ args.force = flags & SEND_FORCE;
+ args.no_contents = flags & SEND_NO_CONTENTS;
err = start_recursion
(send_fileproc, send_filesdoneproc,
- send_dirent_proc, (DIRLEAVEPROC)NULL,
- argc, argv, local, W_LOCAL, aflag, 0, (char *)NULL, 0, 0);
+ send_dirent_proc, (DIRLEAVEPROC)NULL, (void *) &args,
+ argc, argv, local, W_LOCAL, aflag, 0, (char *)NULL, 0);
if (err)
- exit (EXIT_FAILURE);
+ error_exit ();
if (toplevel_repos == NULL)
/*
* This happens if we are not processing any files,
@@ -3987,7 +4746,7 @@ send_files (argc, argv, local, aflag)
* latter case; I don't think toplevel_repos matters for the
* former.
*/
- toplevel_repos = xstrdup (server_cvsroot);
+ toplevel_repos = xstrdup (CVSroot_directory);
send_repository ("", toplevel_repos, ".");
}
@@ -4003,36 +4762,56 @@ client_import_setup (repository)
* Process the argument import file.
*/
int
-client_process_import_file (message, vfile, vtag, targc, targv, repository)
+client_process_import_file (message, vfile, vtag, targc, targv, repository,
+ all_files_binary)
char *message;
char *vfile;
char *vtag;
int targc;
char *targv[];
char *repository;
+ int all_files_binary;
{
- char *short_pathname;
- int first_time;
-
- /* FIXME: I think this is always false now that we call
- client_import_setup at the start. */
-
- first_time = toplevel_repos == NULL;
+ char *update_dir;
+ char *fullname;
+ Vers_TS vers;
- if (first_time)
- send_a_repository ("", repository, "");
+ assert (toplevel_repos != NULL);
if (strncmp (repository, toplevel_repos, strlen (toplevel_repos)) != 0)
error (1, 0,
"internal error: pathname `%s' doesn't specify file in `%s'",
repository, toplevel_repos);
- short_pathname = repository + strlen (toplevel_repos) + 1;
- if (!first_time)
+ if (strcmp (repository, toplevel_repos) == 0)
+ {
+ update_dir = "";
+ fullname = xstrdup (vfile);
+ }
+ else
+ {
+ update_dir = repository + strlen (toplevel_repos) + 1;
+
+ fullname = xmalloc (strlen (vfile) + strlen (update_dir) + 10);
+ strcpy (fullname, update_dir);
+ strcat (fullname, "/");
+ strcat (fullname, vfile);
+ }
+
+ send_a_repository ("", repository, update_dir);
+ if (all_files_binary)
+ {
+ vers.options = xmalloc (4); /* strlen("-kb") + 1 */
+ strcpy (vers.options, "-kb");
+ }
+ else
{
- send_a_repository ("", repository, short_pathname);
+ vers.options = wrap_rcsoption (vfile, 1);
}
- send_modified (vfile, short_pathname, NULL);
+ send_modified (vfile, fullname, &vers);
+ if (vers.options != NULL)
+ free (vers.options);
+ free (fullname);
return 0;
}
@@ -4049,7 +4828,7 @@ client_import_done ()
*/
/* FIXME: "can't happen" now that we call client_import_setup
at the beginning. */
- toplevel_repos = xstrdup (server_cvsroot);
+ toplevel_repos = xstrdup (CVSroot_directory);
send_repository ("", toplevel_repos, ".");
}
@@ -4092,9 +4871,10 @@ notified_a_file (data, ent_list, short_pathname, filename)
{
if (feof (fp))
{
+ free (line);
if (fclose (fp) < 0)
error (0, errno, "cannot close %s", CVSADM_NOTIFY);
- if (unlink (CVSADM_NOTIFY) < 0)
+ if ( CVS_UNLINK (CVSADM_NOTIFY) < 0)
error (0, errno, "cannot remove %s", CVSADM_NOTIFY);
return;
}
@@ -4134,6 +4914,7 @@ notified_a_file (data, ent_list, short_pathname, filename)
error (0, errno, "cannot close %s", CVSADM_NOTIFYTMP);
goto error_exit;
}
+ free (line);
if (fclose (fp) < 0)
{
error (0, errno, "cannot close %s", CVSADM_NOTIFY);
@@ -4152,6 +4933,7 @@ notified_a_file (data, ent_list, short_pathname, filename)
error2:
(void) fclose (newf);
error_exit:
+ free (line);
(void) fclose (fp);
}
@@ -4234,257 +5016,13 @@ client_senddate (date)
option_with_arg ("-D", buf);
}
-int
-client_commit (argc, argv)
- int argc;
- char **argv;
-{
- parse_cvsroot ();
-
- return commit (argc, argv);
-}
-
-int
-client_update (argc, argv)
- int argc;
- char **argv;
-{
- parse_cvsroot ();
-
- return update (argc, argv);
-}
-
-int
-client_checkout (argc, argv)
- int argc;
- char **argv;
-{
- parse_cvsroot ();
-
- return checkout (argc, argv);
-}
-
-int
-client_diff (argc, argv)
- int argc;
- char **argv;
-{
- parse_cvsroot ();
-
- return diff (argc, argv); /* Call real code */
-}
-
-int
-client_status (argc, argv)
- int argc;
- char **argv;
-{
- parse_cvsroot ();
- return status (argc, argv);
-}
-
-int
-client_log (argc, argv)
- int argc;
- char **argv;
-{
-
- parse_cvsroot ();
-
- return cvslog (argc, argv); /* Call real code */
-}
-
-int
-client_add (argc, argv)
- int argc;
- char **argv;
-{
-
- parse_cvsroot ();
-
- return add (argc, argv); /* Call real code */
-}
-
-int
-client_remove (argc, argv)
- int argc;
- char **argv;
-{
-
- parse_cvsroot ();
-
- return cvsremove (argc, argv); /* Call real code */
-}
-
-int
-client_rdiff (argc, argv)
- int argc;
- char **argv;
-{
-
- parse_cvsroot ();
-
- return patch (argc, argv); /* Call real code */
-}
-
-int
-client_tag (argc, argv)
- int argc;
- char **argv;
-{
-
- parse_cvsroot ();
-
- return tag (argc, argv); /* Call real code */
-}
-
-int
-client_rtag (argc, argv)
- int argc;
- char **argv;
-{
-
- parse_cvsroot ();
-
- return rtag (argc, argv); /* Call real code */
-}
-
-int
-client_import (argc, argv)
- int argc;
- char **argv;
-{
-
- parse_cvsroot ();
-
- return import (argc, argv); /* Call real code */
-}
-
-int
-client_admin (argc, argv)
- int argc;
- char **argv;
-{
-
- parse_cvsroot ();
-
- return admin (argc, argv); /* Call real code */
-}
-
-int
-client_export (argc, argv)
- int argc;
- char **argv;
-{
-
- parse_cvsroot ();
-
- return checkout (argc, argv); /* Call real code */
-}
-
-int
-client_history (argc, argv)
- int argc;
- char **argv;
-{
-
- parse_cvsroot ();
-
- return history (argc, argv); /* Call real code */
-}
-
-int
-client_release (argc, argv)
- int argc;
- char **argv;
-{
-
- parse_cvsroot ();
-
- return release (argc, argv); /* Call real code */
-}
-
-int
-client_watch (argc, argv)
- int argc;
- char **argv;
-{
-
- parse_cvsroot ();
-
- return watch (argc, argv); /* Call real code */
-}
-
-int
-client_watchers (argc, argv)
- int argc;
- char **argv;
-{
-
- parse_cvsroot ();
-
- return watchers (argc, argv); /* Call real code */
-}
-
-int
-client_editors (argc, argv)
- int argc;
- char **argv;
-{
-
- parse_cvsroot ();
-
- return editors (argc, argv); /* Call real code */
-}
-
-int
-client_edit (argc, argv)
- int argc;
- char **argv;
-{
-
- parse_cvsroot ();
-
- return edit (argc, argv); /* Call real code */
-}
-
-int
-client_unedit (argc, argv)
- int argc;
- char **argv;
-{
-
- parse_cvsroot ();
-
- return unedit (argc, argv); /* Call real code */
-}
-
void
send_init_command ()
{
- /* This is here because we need the server_cvsroot variable. */
+ /* This is here because we need the CVSroot_directory variable. */
send_to_server ("init ", 0);
- send_to_server (server_cvsroot, 0);
+ send_to_server (CVSroot_directory, 0);
send_to_server ("\012", 0);
}
-int
-client_init (argc, argv)
- int argc;
- char **argv;
-{
- parse_cvsroot ();
-
- return init (argc, argv); /* Call real code */
-}
-
-int
-client_annotate (argc, argv)
- int argc;
- char **argv;
-{
- parse_cvsroot ();
-
- return annotate (argc, argv); /* Call real code */
-}
#endif /* CLIENT_SUPPORT */