diff options
Diffstat (limited to 'src/client.c')
| -rw-r--r-- | src/client.c | 5180 |
1 files changed, 5180 insertions, 0 deletions
diff --git a/src/client.c b/src/client.c new file mode 100644 index 0000000..751406b --- /dev/null +++ b/src/client.c @@ -0,0 +1,5180 @@ +/* CVS client-related stuff. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif /* HAVE_CONFIG_H */ + +#include "cvs.h" +#include "getline.h" +#include "edit.h" +#include "buffer.h" +#include "save-cwd.h" + +#ifdef CLIENT_SUPPORT + +# include "log-buffer.h" +# include "md5.h" + +#include "socket-client.h" +#include "rsh-client.h" + +# ifdef HAVE_GSSAPI +# include "gssapi-client.h" +# endif + +# ifdef HAVE_KERBEROS +# include "kerberos4-client.h" +# endif + + + +/* Keep track of any paths we are sending for Max-dotdot so that we can verify + * that uplevel paths coming back form the server are valid. + * + * FIXME: The correct way to do this is probably provide some sort of virtual + * path map on the client side. This would be generic enough to be applied to + * absolute paths supplied by the user too. + */ +static List *uppaths; + + + +static void add_prune_candidate (const char *); + +/* All the commands. */ +int add (int argc, char **argv); +int admin (int argc, char **argv); +int checkout (int argc, char **argv); +int commit (int argc, char **argv); +int diff (int argc, char **argv); +int history (int argc, char **argv); +int import (int argc, char **argv); +int cvslog (int argc, char **argv); +int patch (int argc, char **argv); +int release (int argc, char **argv); +int cvsremove (int argc, char **argv); +int rtag (int argc, char **argv); +int status (int argc, char **argv); +int tag (int argc, char **argv); +int update (int argc, char **argv); + +static size_t try_read_from_server (char *, size_t); + +static void auth_server (cvsroot_t *, struct buffer *, struct buffer *, + int, int, struct hostent *); + + + +/* This is the referrer who referred us to a primary, or write server, using + * the "Redirect" request. + */ +static cvsroot_t *client_referrer; + +/* We need to keep track of the list of directories we've sent to the + server. This list, along with the current CVSROOT, will help us + decide which command-line arguments to send. */ +List *dirs_sent_to_server; +static int +is_arg_a_parent_or_listed_dir (Node *n, void *d) +{ + char *directory = n->key; /* name of the dir sent to server */ + char *this_argv_elem = d; /* this argv element */ + + /* Say we should send this argument if the argument matches the + beginning of a directory name sent to the server. This way, + the server will know to start at the top of that directory + hierarchy and descend. */ + + if (!strncmp (directory, this_argv_elem, strlen (this_argv_elem))) + return 1; + + return 0; +} + + + +/* Return nonzero if this argument should not be sent to the + server. */ +static int +arg_should_not_be_sent_to_server (char *arg) +{ + /* Decide if we should send this directory name to the server. We + should always send argv[i] if: + + 1) the list of directories sent to the server is empty (as it + will be for checkout, etc.). + + 2) the argument is "." + + 3) the argument is a file in the cwd and the cwd is checked out + from the current root + + 4) the argument lies within one of the paths in + dirs_sent_to_server. + + */ + + if (list_isempty (dirs_sent_to_server)) + return 0; /* always send it */ + + if (!strcmp (arg, ".")) + return 0; /* always send it */ + + /* We should send arg if it is one of the directories sent to the + server or the parent of one; this tells the server to descend + the hierarchy starting at this level. */ + if (isdir (arg)) + { + if (walklist (dirs_sent_to_server, is_arg_a_parent_or_listed_dir, arg)) + return 0; + + /* If arg wasn't a parent, we don't know anything about it (we + would have seen something related to it during the + send_files phase). Don't send it. */ + return 1; + } + + /* Try to decide whether we should send arg to the server by + checking the contents of the corresponding CVSADM directory. */ + { + char *t, *root_string; + cvsroot_t *this_root = NULL; + + /* Calculate "dirname arg" */ + for (t = arg + strlen (arg) - 1; t >= arg; t--) + { + if (ISSLASH (*t)) + break; + } + + /* Now we're either poiting to the beginning of the + string, or we found a path separator. */ + if (t >= arg) + { + /* Found a path separator. */ + char c = *t; + *t = '\0'; + + /* First, check to see if we sent this directory to the + server, because it takes less time than actually + opening the stuff in the CVSADM directory. */ + if (walklist (dirs_sent_to_server, is_arg_a_parent_or_listed_dir, + arg)) + { + *t = c; /* make sure to un-truncate the arg */ + return 0; + } + + /* Since we didn't find it in the list, check the CVSADM + files on disk. */ + this_root = Name_Root (arg, NULL); + root_string = this_root->original; + *t = c; + } + else + { + /* We're at the beginning of the string. Look at the + CVSADM files in cwd. */ + if (CVSroot_cmdline) + root_string = CVSroot_cmdline; + else + { + this_root = Name_Root (NULL, NULL); + root_string = this_root->original; + } + } + + /* Now check the value for root. */ + if (root_string && current_parsed_root + && strcmp (root_string, original_parsed_root->original)) + { + /* Don't send this, since the CVSROOTs don't match. */ + return 1; + } + } + + /* OK, let's send it. */ + return 0; +} +#endif /* CLIENT_SUPPORT */ + + + +#if defined(CLIENT_SUPPORT) || defined(SERVER_SUPPORT) + +/* Shared with server. */ + +/* + * Return a malloc'd, '\0'-terminated string + * corresponding to the mode in SB. + */ +char * +mode_to_string (mode_t mode) +{ + char 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'; + + return Xasprintf ("u=%s,g=%s,o=%s", u, g, o); +} + + + +/* + * Change mode of FILENAME to MODE_STRING. + * Returns 0 for success or errno code. + * If RESPECT_UMASK is set, then honor the umask. + */ +int +change_mode (const char *filename, const char *mode_string, int respect_umask) +{ +#ifdef CHMOD_BROKEN + char *p; + int writeable = 0; + + /* We can only distinguish between + 1) readable + 2) writeable + 3) Picasso's "Blue Period" + We handle the first two. */ + p = mode_string; + while (*p != '\0') + { + if ((p[0] == 'u' || p[0] == 'g' || p[0] == 'o') && p[1] == '=') + { + char *q = p + 2; + while (*q != ',' && *q != '\0') + { + if (*q == 'w') + writeable = 1; + ++q; + } + } + /* Skip to the next field. */ + while (*p != ',' && *p != '\0') + ++p; + if (*p == ',') + ++p; + } + + /* xchmod honors the umask for us. In the !respect_umask case, we + don't try to cope with it (probably to handle that well, the server + needs to deal with modes in data structures, rather than via the + modes in temporary files). */ + xchmod (filename, writeable); + return 0; + +#else /* ! CHMOD_BROKEN */ + + const char *p; + mode_t mode = 0; + mode_t oumask; + + p = mode_string; + while (*p != '\0') + { + if ((p[0] == 'u' || p[0] == 'g' || p[0] == 'o') && p[1] == '=') + { + int can_read = 0, can_write = 0, can_execute = 0; + const char *q = p + 2; + while (*q != ',' && *q != '\0') + { + if (*q == 'r') + can_read = 1; + else if (*q == 'w') + can_write = 1; + else if (*q == 'x') + can_execute = 1; + ++q; + } + if (p[0] == 'u') + { + if (can_read) + mode |= S_IRUSR; + if (can_write) + mode |= S_IWUSR; + if (can_execute) + mode |= S_IXUSR; + } + else if (p[0] == 'g') + { + if (can_read) + mode |= S_IRGRP; + if (can_write) + mode |= S_IWGRP; + if (can_execute) + mode |= S_IXGRP; + } + else if (p[0] == 'o') + { + if (can_read) + mode |= S_IROTH; + if (can_write) + mode |= S_IWOTH; + if (can_execute) + mode |= S_IXOTH; + } + } + /* Skip to the next field. */ + while (*p != ',' && *p != '\0') + ++p; + if (*p == ',') + ++p; + } + + if (respect_umask) + { + oumask = umask (0); + (void) umask (oumask); + mode &= ~oumask; + } + + if (chmod (filename, mode) < 0) + return errno; + return 0; +#endif /* ! CHMOD_BROKEN */ +} +#endif /* CLIENT_SUPPORT or SERVER_SUPPORT */ + + + +#ifdef CLIENT_SUPPORT +int client_prune_dirs; + +static List *ignlist = NULL; + +/* Buffer to write to the server. */ +static struct buffer *global_to_server; + +/* Buffer used to read from the server. */ +static struct buffer *global_from_server; + + + +/* + * 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 size_t +read_line_via (struct buffer *via_from_buffer, struct buffer *via_to_buffer, + char **resultp) +{ + int status; + char *result; + size_t len; + + status = buf_flush (via_to_buffer, 1); + if (status != 0) + error (1, status, "writing to server"); + + status = buf_read_line (via_from_buffer, &result, &len); + if (status != 0) + { + 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) + *resultp = result; + else + free (result); + + return len; +} + + + +static size_t +read_line (char **resultp) +{ + return read_line_via (global_from_server, global_to_server, resultp); +} +#endif /* CLIENT_SUPPORT */ + + + +#if defined(CLIENT_SUPPORT) || defined(SERVER_SUPPORT) +/* + * Zero if compression isn't supported or requested; non-zero to indicate + * a compression level to request from gzip. + */ +int gzip_level; + +/* + * Level of compression to use when running gzip on a single file. + */ +int file_gzip_level; + +#endif /* CLIENT_SUPPORT or SERVER_SUPPORT */ + +#ifdef CLIENT_SUPPORT + +/* Whether the server asked us to force compression. */ +static bool force_gzip; + +/* + * The Repository for the top level of this command (not necessarily + * the CVSROOT, just the current directory at the time we do it). + */ +static char *toplevel_repos; + +/* 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 (char *args, size_t len) +{ + return; +} + + + +static void +handle_error (char *args, size_t len) +{ + int something_printed; + + /* + * First there is a symbolic error code followed by a space, which + * we ignore. + */ + char *p = strchr (args, ' '); + if (!p) + { + error (0, 0, "invalid data from cvs server"); + return; + } + ++p; + + /* Next we print the text of the message from the server. We + probably should be prefixing it with "server error" or some + such, because if it is something like "Out of memory", the + current behavior doesn't say which machine is out of + memory. */ + + len -= p - args; + something_printed = 0; + for (; len > 0; --len) + { + something_printed = 1; + putc (*p++, stderr); + } + if (something_printed) + putc ('\n', stderr); +} + + + +static void +handle_valid_requests (char *args, size_t len) +{ + char *p = args; + char *q; + struct request *rq; + do + { + q = strchr (p, ' '); + if (q) + *q++ = '\0'; + for (rq = requests; rq->name; ++rq) + { + if (!strcmp (rq->name, p)) + break; + } + if (!rq->name) + /* + * It is a request we have never heard of (and thus never + * will want to use). So don't worry about it. + */ + ; + else + { + if (rq->flags & RQ_ENABLEME) + { + /* + * Server wants to know if we have this, to enable the + * feature. + */ + send_to_server (rq->name, 0); + send_to_server ("\012", 0); + } + else + rq->flags |= RQ_SUPPORTED; + } + p = q; + } while (q); + for (rq = requests; rq->name; ++rq) + { + if ((rq->flags & RQ_SUPPORTED) + || (rq->flags & RQ_ENABLEME)) + continue; + if (rq->flags & RQ_ESSENTIAL) + error (1, 0, "request `%s' not supported by server", rq->name); + } +} + +static void +handle_force_gzip (char *args, size_t len) +{ + force_gzip = true; +} + + + +/* Has the server told us its name since the last redirect? + */ +static bool referred_since_last_redirect = false; +static bool free_client_referrer = false; + + + +static void +handle_referrer (char *args, size_t len) +{ + TRACE (TRACE_FUNCTION, "handle_referrer (%s)", args); + client_referrer = parse_cvsroot (args); + referred_since_last_redirect = true; + free_client_referrer = true; +} + + + +/* Redirect our connection to a different server and start over. + * + * GLOBALS + * current_parsed_root The CVSROOT being accessed. + * client_referrer Used to track the server which referred us to a + * new server. Can be supplied by the referring + * server. + * free_client_referrer Used to track whether the client_referrer needs + * to be freed before changing it. + * referred_since_last_redirect + * Tracks whether the currect server told us how + * to refer to it. + * + * OUTPUTS + * current_parsed_root Updated to point to the new CVSROOT. + * referred_since_last_redirect + * Always cleared. + * client_referrer Set automatically to current_parsed_root if + * the current server did not give us a name to + * refer to it by. + * free_client_referrer Reset when necessary. + */ +static void +handle_redirect (char *args, size_t len) +{ + static List *redirects = NULL; + + TRACE (TRACE_FUNCTION, "handle_redirect (%s)", args); + + if (redirects && findnode (redirects, args)) + error (1, 0, "`Redirect' loop detected. Server misconfiguration?"); + else + { + if (!redirects) redirects = getlist(); + push_string (redirects, args); + } + + if (referred_since_last_redirect) + referred_since_last_redirect = false; + else + { + if (free_client_referrer) free (client_referrer); + client_referrer = current_parsed_root; + free_client_referrer = false; + } + + current_parsed_root = parse_cvsroot (args); + + /* We deliberately do not set ORIGINAL_PARSED_ROOT here. + * ORIGINAL_PARSED_ROOT is used by the client to determine the current root + * being processed for the purpose of looking it up in lists and such, even + * after a redirect. + * + * FIXME + * CURRENT_PARSED_ROOT should not be reset by this function. Redirects + * should be "added" to it. The REDIRECTS list should also be replaced + * by this new CURRENT_PARSED_ROOT element. This way, if, for instance, + * a multi-root workspace had two secondaries pointing to the same + * primary, then the client would not report a looping error. + * + * There is also a potential memory leak above and storing new roots as + * part of the original could help avoid it fairly elegantly. + */ + if (!current_parsed_root) + error (1, 0, "Server requested redirect to invalid root: `%s'", + args); +} + + + +/* + * This is a proc for walklist(). It inverts the error return premise of + * walklist. + * + * RETURNS + * True If this path is prefixed by one of the paths in walklist and + * does not step above the prefix path. + * False Otherwise. + */ +static +int path_list_prefixed (Node *p, void *closure) +{ + const char *questionable = closure; + const char *prefix = p->key; + if (strncmp (prefix, questionable, strlen (prefix))) return 0; + questionable += strlen (prefix); + while (ISSLASH (*questionable)) questionable++; + if (*questionable == '\0') return 1; + return pathname_levels (questionable); +} + + + +/* + * Need to validate the client pathname. Disallowed paths include: + * + * 1. Absolute paths. + * 2. Pathnames that do not reference a specifically requested update + * directory. + * + * In case 2, we actually only check that the directory is under the uppermost + * directories mentioned on the command line. + * + * RETURNS + * True If the path is valid. + * False Otherwise. + */ +static +int is_valid_client_path (const char *pathname) +{ + /* 1. Absolute paths. */ + if (ISABSOLUTE (pathname)) return 0; + /* 2. No up-references in path. */ + if (pathname_levels (pathname) == 0) return 1; + /* 2. No Max-dotdot paths registered. */ + if (!uppaths) return 0; + + return walklist (uppaths, path_list_prefixed, (void *)pathname); +} + + + +/* + * Do all the processing for PATHNAME, where pathname consists of the + * repository and the filename. The parameters we pass to FUNC are: + * DATA is just the DATA parameter which was passed to + * call_in_directory; ENT_LIST is a pointer to an entries list (which + * we manage the storage for); SHORT_PATHNAME is the pathname of the + * file relative to the (overall) directory in which the command is + * taking place; and FILENAME is the filename portion only of + * SHORT_PATHNAME. When we call FUNC, the curent directory points to + * the directory portion of SHORT_PATHNAME. */ +static void +call_in_directory (const char *pathname, + void (*func) (void *, List *, const char *, const char *), + void *data) +{ + /* This variable holds the result of Entries_Open. */ + List *last_entries = NULL; + char *dir_name; + char *filename; + /* 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; + + /* + * Do the whole descent in parallel for the repositories, so we + * know what to put in CVS/Repository files. I'm not sure the + * full hair is necessary since the server does a similar + * computation; I suspect that we only end up creating one + * directory at a time anyway. + * + * Also note that we must *only* worry about this stuff when we + * are creating directories; `cvs co foo/bar; cd foo/bar; cvs co + * CVSROOT; cvs update' is legitimate, but in this case + * foo/bar/CVSROOT/CVS/Repository is not a subdirectory of + * foo/bar/CVS/Repository. + */ + char *reposname; + char *short_repos; + char *reposdirname; + char *rdirp; + int reposdirname_absolute; + int newdir = 0; + + assert (pathname); + + reposname = NULL; + read_line (&reposname); + assert (reposname); + + reposdirname_absolute = 0; + if (strncmp (reposname, toplevel_repos, strlen (toplevel_repos))) + { + reposdirname_absolute = 1; + short_repos = reposname; + } + else + { + short_repos = reposname + strlen (toplevel_repos) + 1; + if (short_repos[-1] != '/') + { + reposdirname_absolute = 1; + short_repos = reposname; + } + } + + /* Now that we have SHORT_REPOS, we can calculate the path to the file we + * are being requested to operate on. + */ + filename = strrchr (short_repos, '/'); + if (!filename) + filename = short_repos; + else + ++filename; + + short_pathname = xmalloc (strlen (pathname) + strlen (filename) + 5); + strcpy (short_pathname, pathname); + strcat (short_pathname, filename); + + /* Now that we know the path to the file we were requested to operate on, + * we can verify that it is valid. + * + * For security reasons, if SHORT_PATHNAME is absolute or attempts to + * ascend outside of the current sanbbox, we abort. The server should not + * send us anything but relative paths which remain inside the sandbox + * here. Anything less means a trojan CVS server could create and edit + * arbitrary files on the client. + */ + if (!is_valid_client_path (short_pathname)) + { + error (0, 0, + "Server attempted to update a file via an invalid pathname:"); + error (1, 0, "`%s'.", short_pathname); + } + + reposdirname = xstrdup (short_repos); + p = strrchr (reposdirname, '/'); + if (!p) + { + reposdirname = xrealloc (reposdirname, 2); + reposdirname[0] = '.'; reposdirname[1] = '\0'; + } + else + *p = '\0'; + + dir_name = xstrdup (pathname); + p = strrchr (dir_name, '/'); + if (!p) + { + dir_name = xrealloc (dir_name, 2); + dir_name[0] = '.'; dir_name[1] = '\0'; + } + else + *p = '\0'; + if (client_prune_dirs) + add_prune_candidate (dir_name); + + if (!toplevel_wd) + { + toplevel_wd = xgetcwd (); + if (!toplevel_wd) + error (1, errno, "could not get working directory"); + } + + if (CVS_CHDIR (toplevel_wd) < 0) + error (1, errno, "could not chdir to %s", toplevel_wd); + + /* 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). We only need to do this for the "." case, + since the server takes care of forcing this directory to be + created in all other cases. If we don't create CVSADM + here, the call to Entries_Open below will fail. FIXME: + perhaps this means that we should change our algorithm + below that calls Create_Admin instead of having this code + here? */ + 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 + && !strcmp (dir_name, ".") + && ! isdir (CVSADM)) + { + char *repo; + char *r; + + newdir = 1; + + /* If toplevel_repos doesn't have at least one character, then the + * reference to r[-1] below could be out of bounds. + */ + assert (*toplevel_repos); + + repo = xmalloc (strlen (toplevel_repos) + + 10); + strcpy (repo, toplevel_repos); + r = repo + strlen (repo); + if (r[-1] != '.' || r[-2] != '/') + strcpy (r, "/."); + + Create_Admin (".", ".", repo, NULL, NULL, 0, 1, 1); + + free (repo); + } + + if (CVS_CHDIR (dir_name) < 0) + { + char *dir; + char *dirp; + + if (! existence_error (errno)) + 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; + + /* This algorithm makes nested directories one at a time + and create CVS administration files in them. For + example, we're checking out foo/bar/baz from the + repository: + + 1) create foo, point CVS/Repository to <root>/foo + 2) .. foo/bar .. <root>/foo/bar + 3) .. foo/bar/baz .. <root>/foo/bar/baz + + As you can see, we're just stepping along DIR_NAME (with + DIRP) and REPOSDIRNAME (with RDIRP) respectively. + + We need to be careful when we are checking out a + module, however, since DIR_NAME and REPOSDIRNAME are not + going to be the same. Since modules will not have any + slashes in their names, we should watch the output of + STRCHR to decide whether or not we should use STRCHR on + the RDIRP. That is, if we're down to a module name, + don't keep picking apart the repository directory name. */ + + do + { + dirp = strchr (dirp, '/'); + if (dirp) + { + strncpy (dir, dir_name, dirp - dir_name); + dir[dirp - dir_name] = '\0'; + /* Skip the slash. */ + ++dirp; + if (!rdirp) + /* 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, '/'); + } + 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 + should be down to a DIRP that has no slashes, + so it won't help/hurt to do another STRCHR call + on DIRP. It will definitely hurt, however, if + we're down to a module name, since a module + name can point to a nested directory (that is, + DIRP will still have slashes in it. Therefore, + we should set it to NULL so the routine below + copies the contents of REMOTEDIRNAME onto the + root repository directory (does this if rdirp + is set to NULL, because we used to do an extra + STRCHR call here). */ + + 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 (mkdir_if_needed (dir)) + { + /* It already existed, fine. Just keep going. */ + } + else if (!strcmp (cvs_cmd_name, "export")) + /* Don't create CVSADM directories if this is export. */ + ; + else + { + /* + * Put repository in CVS/Repository. For historical + * (pre-CVS/Root) reasons, this is an absolute pathname, + * but what really matters is the part of it which is + * relative to cvsroot. + */ + char *repo; + char *r, *b; + + repo = xmalloc (strlen (reposdirname) + + strlen (toplevel_repos) + + 80); + if (reposdirname_absolute) + r = repo; + else + { + strcpy (repo, toplevel_repos); + strcat (repo, "/"); + r = repo + strlen (repo); + } + + 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'; + } + else + strcpy (r, reposdirname); + + Create_Admin (dir, dir, repo, NULL, NULL, 0, 0, 1); + free (repo); + + b = strrchr (dir, '/'); + if (!b) + Subdir_Register (NULL, NULL, dir); + else + { + *b = '\0'; + Subdir_Register (NULL, dir, b + 1); + *b = '/'; + } + } + + if (rdirp) + { + /* Skip the slash. */ + ++rdirp; + } + + } while (dirp); + free (dir); + /* Now it better work. */ + if (CVS_CHDIR (dir_name) < 0) + error (1, errno, "could not chdir to %s", dir_name); + } + else if (!strcmp (cvs_cmd_name, "export")) + /* Don't create CVSADM directories if this is export. */ + ; + else if (!isdir (CVSADM)) + { + /* + * Put repository in CVS/Repository. For historical + * (pre-CVS/Root) reasons, this is an absolute pathname, + * but what really matters is the part of it which is + * relative to cvsroot. + */ + char *repo; + + if (reposdirname_absolute) + repo = reposdirname; + else + repo = Xasprintf ("%s/%s", toplevel_repos, reposdirname); + + Create_Admin (".", ".", repo, NULL, NULL, 0, 1, 1); + if (repo != reposdirname) + free (repo); + } + + if (strcmp (cvs_cmd_name, "export")) + { + last_entries = Entries_Open (0, dir_name); + + /* 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 (NULL, W_LOCAL, last_entries); + dellist (&dirlist); + } + } + free (reposdirname); + (*func) (data, last_entries, short_pathname, filename); + if (last_entries) + Entries_Close (last_entries); + free (dir_name); + free (short_pathname); + free (reposname); +} + + + +static void +copy_a_file (void *data, List *ent_list, const char *short_pathname, + const char *filename) +{ + char *newname; + + read_line (&newname); + +#ifdef USE_VMS_FILENAMES + { + /* Mogrify the filename so VMS is happy with it. */ + char *p; + for(p = newname; *p; p++) + if(*p == '.' || *p == '#') *p = '_'; + } +#endif + /* cvsclient.texi has said for a long time that newname must be in the + same directory. Wouldn't want a malicious or buggy server overwriting + ~/.profile, /etc/passwd, or anything like that. */ + if (last_component (newname) != newname) + error (1, 0, "protocol error: Copy-file tried to specify directory"); + + if (unlink_file (newname) && !existence_error (errno)) + error (0, errno, "unable to remove %s", newname); + copy_file (filename, newname); + free (newname); +} + + + +static void +handle_copy_file (char *args, size_t len) +{ + call_in_directory (args, copy_a_file, NULL); +} + + + +/* Read from the server the count for the length of a file, then read + the contents of that file and write them to FILENAME. FULLNAME is + the name of the file for use in error messages. FIXME-someday: + extend this to deal with compressed files and make update_entries + use it. On error, gives a fatal error. */ +static void +read_counted_file (char *filename, char *fullname) +{ + char *size_string; + size_t size; + char *buf; + + /* Pointers in buf to the place to put data which will be read, + and the data which needs to be written, respectively. */ + char *pread; + char *pwrite; + /* Number of bytes left to read and number of bytes in buf waiting to + be written, respectively. */ + size_t nread; + size_t nwrite; + + FILE *fp; + + read_line (&size_string); + if (size_string[0] == 'z') + error (1, 0, "\ +protocol error: compressed files not supported for that operation"); + /* FIXME: should be doing more error checking, probably. Like using + strtoul and making sure we used up the whole line. */ + size = atoi (size_string); + free (size_string); + + /* A more sophisticated implementation would use only a limited amount + of buffer space (8K perhaps), and read that much at a time. We allocate + a buffer for the whole file only to make it easy to keep track what + needs to be read and written. */ + buf = xmalloc (size); + + /* FIXME-someday: caller should pass in a flag saying whether it + is binary or not. I haven't carefully looked into whether + CVS/Template files should use local text file conventions or + not. */ + fp = CVS_FOPEN (filename, "wb"); + if (!fp) + error (1, errno, "cannot write %s", fullname); + nread = size; + nwrite = 0; + pread = buf; + pwrite = buf; + while (nread > 0 || nwrite > 0) + { + size_t n; + + if (nread > 0) + { + n = try_read_from_server (pread, nread); + nread -= n; + pread += n; + nwrite += n; + } + + if (nwrite > 0) + { + n = fwrite (pwrite, sizeof *pwrite, nwrite, fp); + if (ferror (fp)) + error (1, errno, "cannot write %s", fullname); + nwrite -= n; + pwrite += n; + } + } + free (buf); + if (fclose (fp) < 0) + error (1, errno, "cannot close %s", fullname); +} + + + +/* OK, we want to swallow the "U foo.c" response and then output it only + if we can update the file. In the future we probably want some more + systematic approach to parsing tagged text, but for now we keep it + ad hoc. "Why," I hear you cry, "do we not just look at the + Update-existing and Created responses?" That is an excellent question, + and the answer is roughly conservatism/laziness--I haven't read through + update.c enough to figure out the exact correspondence or lack thereof + between those responses and a "U foo.c" line (note that Merged, from + join_file, can be either "C foo" or "U foo" depending on the context). */ +/* Nonzero if we have seen +updated and not -updated. */ +static int updated_seen; +/* Filename from an "fname" tagged response within +updated/-updated. */ +static char *updated_fname; + +/* This struct is used to hold data when reading the +importmergecmd + and -importmergecmd tags. We put the variables in a struct only + for namespace issues. FIXME: As noted above, we need to develop a + more systematic approach. */ +static struct +{ + /* Nonzero if we have seen +importmergecmd and not -importmergecmd. */ + int seen; + /* Number of conflicts, from a "conflicts" tagged response. */ + int conflicts; + /* First merge tag, from a "mergetag1" tagged response. */ + char *mergetag1; + /* Second merge tag, from a "mergetag2" tagged response. */ + char *mergetag2; + /* Repository, from a "repository" tagged response. */ + char *repository; +} importmergecmd; + +/* Nonzero if we should arrange to return with a failure exit status. */ +static bool failure_exit; + + +/* + * 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. + */ +static int stored_checksum_valid; +static unsigned char stored_checksum[16]; +static void +handle_checksum (char *args, size_t len) +{ + char *s; + char buf[3]; + int i; + + if (stored_checksum_valid) + error (1, 0, "Checksum received before last one was used"); + + s = args; + buf[2] = '\0'; + for (i = 0; i < 16; i++) + { + char *bufend; + + buf[0] = *s++; + buf[1] = *s++; + stored_checksum[i] = (char) strtol (buf, &bufend, 16); + if (bufend != buf + 2) + break; + } + + if (i < 16 || *s != '\0') + error (1, 0, "Invalid Checksum response: `%s'", args); + + stored_checksum_valid = 1; +} + + + +/* Mode that we got in a "Mode" response (malloc'd), or NULL if none. */ +static char *stored_mode; +static void +handle_mode (char *args, size_t len) +{ + if (stored_mode) + error (1, 0, "protocol error: duplicate Mode"); + stored_mode = xstrdup (args); +} + + + +/* Nonzero if time was specified in Mod-time. */ +static int stored_modtime_valid; +/* Time specified in Mod-time. */ +static time_t stored_modtime; +static void +handle_mod_time (char *args, size_t len) +{ + struct timespec newtime; + if (stored_modtime_valid) + error (0, 0, "protocol error: duplicate Mod-time"); + if (get_date (&newtime, args, NULL)) + { + /* Truncate nanoseconds. */ + stored_modtime = newtime.tv_sec; + stored_modtime_valid = 1; + } + else + error (0, 0, "protocol error: cannot parse date %s", args); +} + + + +/* + * If we receive a patch, but the patch program fails to apply it, we + * want to request the original file. We keep a list of files whose + * patches have failed. + */ + +char **failed_patches; +int failed_patches_count; + +struct update_entries_data +{ + enum { + /* + * We are just getting an Entries line; the local file is + * correct. + */ + UPDATE_ENTRIES_CHECKIN, + /* We are getting the file contents as well. */ + UPDATE_ENTRIES_UPDATE, + /* + * We are getting a patch against the existing local file, not + * an entire new file. + */ + 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. + */ + char *timestamp; +}; + + + +/* Update the Entries line for this file. */ +static void +update_entries (void *data_arg, List *ent_list, const char *short_pathname, + const char *filename) +{ + char *entries_line; + struct update_entries_data *data = data_arg; + + char *cp; + char *user; + char *vn; + /* Timestamp field. Always empty according to the protocol. */ + char *ts; + char *options = NULL; + char *tag = NULL; + char *date = NULL; + char *tag_or_date; + char *scratch_entries = NULL; + int bin; + +#ifdef UTIME_EXPECTS_WRITABLE + int change_it_back = 0; +#endif + + read_line (&entries_line); + + /* + * Parse the entries line. + */ + scratch_entries = xstrdup (entries_line); + + if (scratch_entries[0] != '/') + error (1, 0, "bad entries line `%s' from server", entries_line); + user = scratch_entries + 1; + if (!(cp = strchr (user, '/'))) + error (1, 0, "bad entries line `%s' from server", entries_line); + *cp++ = '\0'; + vn = cp; + if (!(cp = strchr (vn, '/'))) + error (1, 0, "bad entries line `%s' from server", entries_line); + *cp++ = '\0'; + + ts = cp; + if (!(cp = strchr (ts, '/'))) + error (1, 0, "bad entries line `%s' from server", entries_line); + *cp++ = '\0'; + options = cp; + if (!(cp = strchr (options, '/'))) + error (1, 0, "bad entries line `%s' from server", entries_line); + *cp++ = '\0'; + tag_or_date = cp; + + /* If a slash ends the tag_or_date, ignore everything after it. */ + cp = strchr (tag_or_date, '/'); + if (cp) + *cp = '\0'; + if (*tag_or_date == 'T') + tag = tag_or_date + 1; + else if (*tag_or_date == 'D') + date = tag_or_date + 1; + + /* Done parsing the entries line. */ + + if (data->contents == UPDATE_ENTRIES_UPDATE + || data->contents == UPDATE_ENTRIES_PATCH + || data->contents == UPDATE_ENTRIES_RCS_DIFF) + { + char *size_string; + char *mode_string; + int size; + char *buf; + char *temp_filename; + int use_gzip; + int patch_failed; + + read_line (&mode_string); + + read_line (&size_string); + if (size_string[0] == 'z') + { + use_gzip = 1; + size = atoi (size_string+1); + } + else + { + use_gzip = 0; + size = atoi (size_string); + } + free (size_string); + + /* Note that checking this separately from writing the file is + a race condition: if the existence or lack thereof of the + file changes between now and the actual 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, See 3 for + additional notes. (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. In this case and in case 2, the filename + (short_pathname) printed in the error message will likely _not_ + have the same case as seen by the user in a directory listing. + (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); + if (updated_fname) + { + cvs_output ("C ", 0); + cvs_output (updated_fname, 0); + cvs_output ("\n", 1); + } + failure_exit = true; + + 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 (scratch_entries); + free (entries_line); + + /* The Mode, Mod-time, and Checksum responses should not carry + over to a subsequent Created (or whatever) response, even + in the error case. */ + if (stored_mode) + { + free (stored_mode); + stored_mode = NULL; + } + stored_modtime_valid = 0; + stored_checksum_valid = 0; + + if (updated_fname) + { + free (updated_fname); + updated_fname = NULL; + } + return; + } + + temp_filename = xmalloc (strlen (filename) + 80); +#ifdef USE_VMS_FILENAMES + /* A VMS rename of "blah.dat" to "foo" to implies a + destination of "foo.dat" which is unfortinate for CVS */ + sprintf (temp_filename, "%s_new_", filename); +#else +#ifdef _POSIX_NO_TRUNC + sprintf (temp_filename, ".new.%.9s", filename); +#else /* _POSIX_NO_TRUNC */ + 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 + instead of just LF. Format translation is done in the C + library I/O funtions. Here we tell them whether or not to + convert -- if this file is marked "binary" with the RCS -kb + flag, then we don't want to convert, else we do (because + CVS assumes text files by default). */ + + if (options) + bin = !strcmp (options, "-kb"); + else + bin = 0; + + if (data->contents == UPDATE_ENTRIES_RCS_DIFF) + { + /* This is an RCS change text. We just hold the change + text in memory. */ + + if (use_gzip) + error (1, 0, + "server error: gzip invalid with RCS change text"); + + read_from_server (buf, size); + } + else + { + int fd; + + 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); + free (temp_filename); + free (buf); + goto discard_file_and_return; + } + + if (size > 0) + { + read_from_server (buf, size); + + if (use_gzip) + { + if (gunzip_and_write (fd, short_pathname, + (unsigned char *) buf, size)) + error (1, 0, "aborting due to compression error"); + } + else if (write (fd, buf, size) != size) + error (1, errno, "writing %s", short_pathname); + } + + if (close (fd) < 0) + error (1, errno, "writing %s", short_pathname); + } + + /* This is after we have read the file from the net (a change + from previous versions, where the server would send us + "M U foo.c" before Update-existing or whatever), but before + we finish writing the file (arguably a bug). The timing + affects a user who wants status info about how far we have + gotten, and also affects whether "U foo.c" appears in addition + to various error messages. */ + if (updated_fname) + { + cvs_output ("U ", 0); + cvs_output (updated_fname, 0); + cvs_output ("\n", 1); + free (updated_fname); + updated_fname = 0; + } + + patch_failed = 0; + + if (data->contents == UPDATE_ENTRIES_UPDATE) + { + rename_file (temp_filename, filename); + } + else if (data->contents == UPDATE_ENTRIES_PATCH) + { + /* You might think we could just leave Patched out of + Valid-responses and not get this response. However, if + memory serves, the CVS 1.9 server bases this on -u + (update-patches), and there is no way for us to send -u + or not based on whether the server supports "Rcs-diff". + + Fall back to transmitting entire files. */ + patch_failed = 1; + } + else + { + char *filebuf; + size_t filebufsize; + 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); + filebuf = NULL; + filebufsize = 0; + nread = 0; + + get_file (filename, short_pathname, bin ? FOPEN_BINARY_READ : "r", + &filebuf, &filebufsize, &nread); + /* 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) + { + 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. */ + md5_buffer (patchedbuf, patchedlen, checksum); + 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; + } + + if (! patch_failed) + { + FILE *e; + + e = xfopen (temp_filename, + bin ? FOPEN_BINARY_WRITE : "w"); + if (fwrite (patchedbuf, sizeof *patchedbuf, 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 && ! patch_failed) + { + FILE *e; + struct md5_ctx context; + unsigned char buf[8192]; + unsigned len; + unsigned char checksum[16]; + + /* + * Compute the MD5 checksum. This will normally only be + * used when receiving a patch, so we always compute it + * here on the final file, rather than on the received + * data. + * + * Note that if the file is a text file, we should read it + * here using text mode, so its lines will be terminated the same + * way they were transmitted. + */ + e = CVS_FOPEN (filename, "r"); + if (!e) + error (1, errno, "could not open %s", short_pathname); + + md5_init_ctx (&context); + while ((len = fread (buf, 1, sizeof buf, e)) != 0) + md5_process_bytes (buf, len, &context); + if (ferror (e)) + error (1, errno, "could not read %s", short_pathname); + md5_finish_ctx (&context, checksum); + + fclose (e); + + stored_checksum_valid = 0; + + if (memcmp (checksum, stored_checksum, 16) != 0) + { + if (data->contents != UPDATE_ENTRIES_PATCH) + error (1, 0, "checksum failure on %s", + short_pathname); + + error (0, 0, + "checksum failure after patch to %s; will refetch", + short_pathname); + + patch_failed = 1; + } + } + + if (patch_failed) + { + /* Save this file to retrieve later. */ + failed_patches = xnrealloc (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); + free (scratch_entries); + free (entries_line); + + return; + } + + { + int status = change_mode (filename, mode_string, 1); + if (status != 0) + error (0, status, "cannot change mode of %s", short_pathname); + } + + free (mode_string); + free (buf); + } + + if (stored_mode) + { + change_mode (filename, stored_mode, 1); + free (stored_mode); + stored_mode = NULL; + } + + if (stored_modtime_valid) + { + struct utimbuf t; + + memset (&t, 0, sizeof (t)); + t.modtime = stored_modtime; + (void) time (&t.actime); + +#ifdef UTIME_EXPECTS_WRITABLE + if (!iswritable (filename)) + { + xchmod (filename, 1); + change_it_back = 1; + } +#endif /* UTIME_EXPECTS_WRITABLE */ + + if (utime (filename, &t) < 0) + error (0, errno, "cannot set time on %s", filename); + +#ifdef UTIME_EXPECTS_WRITABLE + if (change_it_back) + { + xchmod (filename, 0); + change_it_back = 0; + } +#endif /* UTIME_EXPECTS_WRITABLE */ + + stored_modtime_valid = 0; + } + + /* + * Process the entries line. Do this after we've written the file, + * since we need the timestamp. + */ + if (strcmp (cvs_cmd_name, "export")) + { + char *local_timestamp; + char *file_timestamp; + + (void) time (&last_register_time); + + local_timestamp = data->timestamp; + if (!local_timestamp || ts[0] == '+') + file_timestamp = time_stamp (filename); + else + file_timestamp = NULL; + + /* + * These special version numbers signify that it is not up to + * date. Create a dummy timestamp which will never compare + * equal to the timestamp of the file. + */ + if (vn[0] == '\0' || !strcmp (vn, "0") || vn[0] == '-') + local_timestamp = "dummy timestamp"; + else if (!local_timestamp) + { + local_timestamp = file_timestamp; + + /* Checking for cvs_cmd_name of "commit" doesn't seem like + the cleanest way to handle this, but it seem to roughly + parallel what the :local: code which calls + mark_up_to_date ends up amounting to. Some day, should + think more about what the Checked-in response means + vis-a-vis both Entries and Base and clarify + cvsclient.texi accordingly. */ + + if (!strcmp (cvs_cmd_name, "commit")) + mark_up_to_date (filename); + } + + Register (ent_list, filename, vn, local_timestamp, + options, tag, date, ts[0] == '+' ? file_timestamp : NULL); + + if (file_timestamp) + free (file_timestamp); + + } + free (scratch_entries); + free (entries_line); +} + + + +static void +handle_checked_in (char *args, size_t 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, &dat); +} + + + +static void +handle_new_entry (char *args, size_t 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, &dat); +} + + + +static void +handle_updated (char *args, size_t 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, &dat); +} + + + +static void +handle_created (char *args, size_t 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, &dat); +} + + + +static void +handle_update_existing (char *args, size_t 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, &dat); +} + + + +static void +handle_merged (char *args, size_t 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, &dat); +} + + + +static void +handle_patched (char *args, size_t 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, &dat); +} + + + +static void +handle_rcs_diff (char *args, size_t 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, &dat); +} + + + +static void +remove_entry (void *data, List *ent_list, const char *short_pathname, + const char *filename) +{ + Scratch_Entry (ent_list, filename); +} + + + +static void +handle_remove_entry (char *args, size_t len) +{ + call_in_directory (args, remove_entry, NULL); +} + + + +static void +remove_entry_and_file (void *data, List *ent_list, const char *short_pathname, + const 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); +} + + + +static void +handle_removed (char *args, size_t len) +{ + call_in_directory (args, remove_entry_and_file, NULL); +} + + + +/* Is this the top level (directory containing CVSROOT)? */ +static int +is_cvsroot_level (char *pathname) +{ + if (strcmp (toplevel_repos, current_parsed_root->directory)) + return 0; + + return !strchr (pathname, '/'); +} + + + +static void +set_static (void *data, List *ent_list, const char *short_pathname, + const char *filename) +{ + FILE *fp; + fp = xfopen (CVSADM_ENTSTAT, "w+"); + if (fclose (fp) == EOF) + error (1, errno, "cannot close %s", CVSADM_ENTSTAT); +} + + + +static void +handle_set_static_directory (char *args, size_t len) +{ + if (!strcmp (cvs_cmd_name, "export")) + { + /* Swallow the repository. */ + read_line (NULL); + return; + } + call_in_directory (args, set_static, NULL); +} + + + +static void +clear_static (void *data, List *ent_list, const char *short_pathname, + const char *filename) +{ + if (unlink_file (CVSADM_ENTSTAT) < 0 && ! existence_error (errno)) + error (1, errno, "cannot remove file %s", CVSADM_ENTSTAT); +} + + + +static void +handle_clear_static_directory (char *pathname, size_t len) +{ + if (!strcmp (cvs_cmd_name, "export")) + { + /* Swallow the repository. */ + read_line (NULL); + return; + } + + if (is_cvsroot_level (pathname)) + { + /* + * Top level (directory containing CVSROOT). This seems to normally + * lack a CVS directory, so don't try to create files in it. + */ + return; + } + call_in_directory (pathname, clear_static, NULL); +} + + + +static void +set_sticky (void *data, List *ent_list, const char *short_pathname, + const char *filename) +{ + char *tagspec; + FILE *f; + + read_line (&tagspec); + + /* FIXME-update-dir: error messages should include the directory. */ + f = CVS_FOPEN (CVSADM_TAG, "w+"); + if (!f) + { + /* Making this non-fatal is a bit of a kludge (see dirs2 + in testsuite). A better solution would be to avoid having + the server tell us about a directory we shouldn't be doing + anything with anyway (e.g. by handling directory + addition/removal better). */ + error (0, errno, "cannot open %s", CVSADM_TAG); + free (tagspec); + return; + } + if (fprintf (f, "%s\n", tagspec) < 0) + error (1, errno, "writing %s", CVSADM_TAG); + if (fclose (f) == EOF) + error (1, errno, "closing %s", CVSADM_TAG); + free (tagspec); +} + + + +static void +handle_set_sticky (char *pathname, size_t len) +{ + if (!strcmp (cvs_cmd_name, "export")) + { + /* Swallow the repository. */ + read_line (NULL); + /* Swallow the tag line. */ + read_line (NULL); + return; + } + if (is_cvsroot_level (pathname)) + { + /* + * Top level (directory containing CVSROOT). This seems to normally + * lack a CVS directory, so don't try to create files in it. + */ + + /* Swallow the repository. */ + read_line (NULL); + /* Swallow the tag line. */ + read_line (NULL); + return; + } + + call_in_directory (pathname, set_sticky, NULL); +} + + + +static void +clear_sticky (void *data, List *ent_list, const char *short_pathname, + const char *filename) +{ + if (unlink_file (CVSADM_TAG) < 0 && ! existence_error (errno)) + error (1, errno, "cannot remove %s", CVSADM_TAG); +} + + + +static void +handle_clear_sticky (char *pathname, size_t len) +{ + if (!strcmp (cvs_cmd_name, "export")) + { + /* Swallow the repository. */ + read_line (NULL); + return; + } + + if (is_cvsroot_level (pathname)) + { + /* + * Top level (directory containing CVSROOT). This seems to normally + * lack a CVS directory, so don't try to create files in it. + */ + return; + } + + call_in_directory (pathname, clear_sticky, NULL); +} + + + +/* Handle the client-side support for a successful edit. + */ +static void +handle_edit_file (char *pathname, size_t len) +{ + call_in_directory (pathname, edit_file, NULL); +} + + + +static void +template (void *data, List *ent_list, const char *short_pathname, + const char *filename) +{ + char *buf = Xasprintf ("%s/%s", short_pathname, CVSADM_TEMPLATE); + read_counted_file (CVSADM_TEMPLATE, buf); + free (buf); +} + + + +static void +handle_template (char *pathname, size_t len) +{ + call_in_directory (pathname, template, NULL); +} + + + +static void +clear_template (void *data, List *ent_list, const char *short_pathname, + const char *filename) +{ + if (unlink_file (CVSADM_TEMPLATE) < 0 && ! existence_error (errno)) + error (1, errno, "cannot remove %s", CVSADM_TEMPLATE); +} + + + +static void +handle_clear_template (char *pathname, size_t len) +{ + call_in_directory (pathname, clear_template, NULL); +} + + + +struct save_dir { + char *dir; + struct save_dir *next; +}; + +struct save_dir *prune_candidates; + +static void +add_prune_candidate (const char *dir) +{ + struct save_dir *p; + + if ((dir[0] == '.' && dir[1] == '\0') + || (prune_candidates && !strcmp (dir, prune_candidates->dir))) + return; + p = xmalloc (sizeof (struct save_dir)); + p->dir = xstrdup (dir); + p->next = prune_candidates; + prune_candidates = p; +} + + + +static void +process_prune_candidates (void) +{ + struct save_dir *p; + struct save_dir *q; + + if (toplevel_wd) + { + if (CVS_CHDIR (toplevel_wd) < 0) + error (1, errno, "could not chdir to %s", toplevel_wd); + } + for (p = prune_candidates; p; ) + { + if (isemptydir (p->dir, 1)) + { + char *b; + + if (unlink_file_dir (p->dir) < 0) + error (0, errno, "cannot remove %s", p->dir); + b = strrchr (p->dir, '/'); + if (!b) + Subdir_Deregister (NULL, NULL, p->dir); + else + { + *b = '\0'; + Subdir_Deregister (NULL, p->dir, b + 1); + } + } + free (p->dir); + q = p->next; + free (p); + p = q; + } + prune_candidates = NULL; +} + + + +/* Send a Repository line. */ +static char *last_repos; +static char *last_update_dir; +static void +send_repository (const char *dir, const char *repos, const char *update_dir) +{ + char *adm_name; + + /* FIXME: this is probably not the best place to check; I wish I + * knew where in here's callers to really trap this bug. To + * reproduce the bug, just do this: + * + * mkdir junk + * cd junk + * cvs -d some_repos update foo + * + * Poof, CVS seg faults and dies! It's because it's trying to + * send a NULL string to the server but dies in send_to_server. + * That string was supposed to be the repository, but it doesn't + * get set because there's no CVSADM dir, and somehow it's not + * getting set from the -d argument either... ? + */ + if (!repos) + { + /* Lame error. I want a real fix but can't stay up to track + this down right now. */ + error (1, 0, "no repository"); + } + + if (!update_dir || update_dir[0] == '\0') + update_dir = "."; + + if (last_repos && !strcmp (repos, last_repos) + && last_update_dir && !strcmp (update_dir, last_update_dir)) + /* We've already sent it. */ + return; + + if (client_prune_dirs) + add_prune_candidate (update_dir); + + /* Add a directory name to the list of those sent to the + server. */ + if (update_dir && *update_dir != '\0' && strcmp (update_dir, ".") + && !findnode (dirs_sent_to_server, update_dir)) + { + Node *n; + n = getnode (); + n->type = NT_UNKNOWN; + n->key = xstrdup (update_dir); + n->data = NULL; + + if (addnode (dirs_sent_to_server, n)) + error (1, 0, "cannot add directory %s to list", n->key); + } + + /* 80 is large enough for any of CVSADM_*. */ + adm_name = xmalloc (strlen (dir) + 80); + + send_to_server ("Directory ", 0); + { + /* Send the directory name. I know that this + sort of duplicates code elsewhere, but each + case seems slightly different... */ + char buf[1]; + const char *p = update_dir; + while (*p != '\0') + { + assert (*p != '\012'); + if (ISSLASH (*p)) + { + buf[0] = '/'; + send_to_server (buf, 1); + } + else + { + buf[0] = *p; + send_to_server (buf, 1); + } + ++p; + } + } + send_to_server ("\012", 1); + if (supported_request ("Relative-directory")) + { + const char *short_repos = Short_Repository (repos); + send_to_server (short_repos, 0); + } + else + send_to_server (repos, 0); + send_to_server ("\012", 1); + + if (supported_request ("Static-directory")) + { + adm_name[0] = '\0'; + if (dir[0] != '\0') + { + strcat (adm_name, dir); + strcat (adm_name, "/"); + } + strcat (adm_name, CVSADM_ENTSTAT); + if (isreadable (adm_name)) + { + send_to_server ("Static-directory\012", 0); + } + } + if (supported_request ("Sticky")) + { + FILE *f; + if (dir[0] == '\0') + strcpy (adm_name, CVSADM_TAG); + else + sprintf (adm_name, "%s/%s", dir, CVSADM_TAG); + + f = CVS_FOPEN (adm_name, "r"); + if (!f) + { + if (! existence_error (errno)) + error (1, errno, "reading %s", adm_name); + } + else + { + char line[80]; + char *nl = NULL; + send_to_server ("Sticky ", 0); + while (fgets (line, sizeof (line), f)) + { + send_to_server (line, 0); + nl = strchr (line, '\n'); + if (nl) + break; + } + if (!nl) + send_to_server ("\012", 1); + if (fclose (f) == EOF) + error (0, errno, "closing %s", adm_name); + } + } + free (adm_name); + if (last_repos) free (last_repos); + if (last_update_dir) free (last_update_dir); + last_repos = xstrdup (repos); + last_update_dir = xstrdup (update_dir); +} + + + +/* Send a Repository line and set toplevel_repos. */ +void +send_a_repository (const char *dir, const char *repository, + const char *update_dir_in) +{ + char *update_dir = xstrdup (update_dir_in); + + if (!toplevel_repos && repository) + { + if (update_dir[0] == '\0' + || (update_dir[0] == '.' && update_dir[1] == '\0')) + toplevel_repos = xstrdup (repository); + else + { + /* + * Get the repository from a CVS/Repository file if update_dir + * is absolute. This is not correct in general, because + * the CVS/Repository file might not be the top-level one. + * This is for cases like "cvs update /foo/bar" (I'm not + * sure it matters what toplevel_repos we get, but it does + * matter that we don't hit the "internal error" code below). + */ + if (update_dir[0] == '/') + toplevel_repos = Name_Repository (update_dir, update_dir); + else + { + /* + * Guess the repository of that directory by looking at a + * subdirectory and removing as many pathname components + * as are in update_dir. I think that will always (or at + * least almost always) be 1. + * + * So this deals with directories which have been + * renamed, though it doesn't necessarily deal with + * directories which have been put inside other + * directories (and cvs invoked on the containing + * directory). I'm not sure the latter case needs to + * work. + * + * 21 Aug 1998: Well, Mr. Above-Comment-Writer, it + * does need to work after all. When we are using the + * client in a multi-cvsroot environment, it will be + * fairly common that we have the above case (e.g., + * cwd checked out from one repository but + * subdirectory checked out from another). We can't + * assume that by walking up a directory in our wd we + * necessarily walk up a directory in the repository. + */ + /* + * This gets toplevel_repos wrong for "cvs update ../foo" + * but I'm not sure toplevel_repos matters in that case. + */ + + int repository_len, update_dir_len; + + strip_trailing_slashes (update_dir); + + repository_len = strlen (repository); + update_dir_len = strlen (update_dir); + + /* Try to remove the path components in UPDATE_DIR + from REPOSITORY. If the path elements don't exist + in REPOSITORY, or the removal of those path + elements mean that we "step above" + current_parsed_root->directory, set toplevel_repos to + current_parsed_root->directory. */ + if (repository_len > update_dir_len + && !strcmp (repository + repository_len - update_dir_len, + update_dir) + /* TOPLEVEL_REPOS shouldn't be above current_parsed_root->directory */ + && ((size_t)(repository_len - update_dir_len) + > strlen (current_parsed_root->directory))) + { + /* The repository name contains UPDATE_DIR. Set + toplevel_repos to the repository name without + UPDATE_DIR. */ + + toplevel_repos = xmalloc (repository_len - update_dir_len); + /* Note that we don't copy the trailing '/'. */ + strncpy (toplevel_repos, repository, + repository_len - update_dir_len - 1); + toplevel_repos[repository_len - update_dir_len - 1] = '\0'; + } + else + { + toplevel_repos = xstrdup (current_parsed_root->directory); + } + } + } + } + + send_repository (dir, repository, update_dir); + free (update_dir); +} + + + +static void +notified_a_file (void *data, List *ent_list, const char *short_pathname, + const char *filename) +{ + FILE *fp; + FILE *newf; + size_t line_len = 8192; + char *line = xmalloc (line_len); + char *cp; + int nread; + int nwritten; + char *p; + + fp = xfopen (CVSADM_NOTIFY, "r"); + if (getline (&line, &line_len, fp) < 0) + { + if (feof (fp)) + error (0, 0, "cannot read %s: end of file", CVSADM_NOTIFY); + else + error (0, errno, "cannot read %s", CVSADM_NOTIFY); + goto error_exit; + } + cp = strchr (line, '\t'); + if (!cp) + { + error (0, 0, "malformed %s file", CVSADM_NOTIFY); + goto error_exit; + } + *cp = '\0'; + if (strcmp (filename, line + 1)) + error (0, 0, "protocol error: notified %s, expected %s", filename, + line + 1); + + if (getline (&line, &line_len, fp) < 0) + { + if (feof (fp)) + { + free (line); + if (fclose (fp) < 0) + error (0, errno, "cannot close %s", CVSADM_NOTIFY); + if ( CVS_UNLINK (CVSADM_NOTIFY) < 0) + error (0, errno, "cannot remove %s", CVSADM_NOTIFY); + return; + } + else + { + error (0, errno, "cannot read %s", CVSADM_NOTIFY); + goto error_exit; + } + } + newf = xfopen (CVSADM_NOTIFYTMP, "w"); + if (fputs (line, newf) < 0) + { + error (0, errno, "cannot write %s", CVSADM_NOTIFYTMP); + goto error2; + } + while ((nread = fread (line, 1, line_len, fp)) > 0) + { + p = line; + while ((nwritten = fwrite (p, sizeof *p, nread, newf)) > 0) + { + nread -= nwritten; + p += nwritten; + } + if (ferror (newf)) + { + error (0, errno, "cannot write %s", CVSADM_NOTIFYTMP); + goto error2; + } + } + if (ferror (fp)) + { + error (0, errno, "cannot read %s", CVSADM_NOTIFY); + goto error2; + } + if (fclose (newf) < 0) + { + 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); + return; + } + + { + /* In this case, we want rename_file() to ignore noexec. */ + int saved_noexec = noexec; + noexec = 0; + rename_file (CVSADM_NOTIFYTMP, CVSADM_NOTIFY); + noexec = saved_noexec; + } + + return; + error2: + (void)fclose (newf); + error_exit: + free (line); + (void)fclose (fp); +} + + + +static void +handle_notified (char *args, size_t len) +{ + call_in_directory (args, notified_a_file, NULL); +} + + + +/* The "expanded" modules. */ +static int modules_count; +static int modules_allocated; +static char **modules_vector; + +static void +handle_module_expansion (char *args, size_t len) +{ + if (!modules_vector) + { + modules_allocated = 1; /* Small for testing */ + modules_vector = xnmalloc (modules_allocated, + sizeof (modules_vector[0])); + } + else if (modules_count >= modules_allocated) + { + modules_allocated *= 2; + modules_vector = xnrealloc (modules_vector, + modules_allocated, + sizeof (modules_vector[0])); + } + modules_vector[modules_count] = xstrdup (args); + ++modules_count; +} + + + +/* Original, not "expanded" modules. */ +static int module_argc; +static char **module_argv; + +void +client_expand_modules (int argc, char **argv, int local) +{ + int errs; + int i; + + module_argc = argc; + module_argv = xnmalloc (argc + 1, sizeof (module_argv[0])); + for (i = 0; i < argc; ++i) + module_argv[i] = xstrdup (argv[i]); + module_argv[argc] = NULL; + + for (i = 0; i < argc; ++i) + send_arg (argv[i]); + send_a_repository ("", current_parsed_root->directory, ""); + + send_to_server ("expand-modules\012", 0); + + errs = get_server_responses (); + + if (last_repos) free (last_repos); + last_repos = NULL; + + if (last_update_dir) free (last_update_dir); + last_update_dir = NULL; + + if (errs) + error (errs, 0, "cannot expand modules"); +} + + + +void +client_send_expansions (int local, char *where, int build_dirs) +{ + int i; + char *argv[1]; + + /* Send the original module names. The "expanded" module name might + not be suitable as an argument to a co request (e.g. it might be + the result of a -d argument in the modules file). It might be + cleaner if we genuinely expanded module names, all the way to a + local directory and repository, but that isn't the way it works + now. */ + send_file_names (module_argc, module_argv, 0); + + for (i = 0; i < modules_count; ++i) + { + argv[0] = where ? where : modules_vector[i]; + if (isfile (argv[0])) + send_files (1, argv, local, 0, build_dirs ? SEND_BUILD_DIRS : 0); + } + send_a_repository ("", current_parsed_root->directory, ""); +} + + + +void +client_nonexpanded_setup (void) +{ + send_a_repository ("", current_parsed_root->directory, ""); +} + + + +/* Receive a cvswrappers line from the server; it must be a line + containing an RCS option (e.g., "*.exe -k 'b'"). + + Note that this doesn't try to handle -t/-f options (which are a + whole separate issue which noone has thought much about, as far + as I know). + + We need to know the keyword expansion mode so we know whether to + read the file in text or binary mode. */ +static void +handle_wrapper_rcs_option (char *args, size_t len) +{ + char *p; + + /* Enforce the notes in cvsclient.texi about how the response is not + as free-form as it looks. */ + p = strchr (args, ' '); + if (!p) + goto handle_error; + if (*++p != '-' + || *++p != 'k' + || *++p != ' ' + || *++p != '\'') + goto handle_error; + if (!strchr (p, '\'')) + goto handle_error; + + /* Add server-side cvswrappers line to our wrapper list. */ + wrap_add (args, 0); + return; + handle_error: + error (0, errno, "protocol error: ignoring invalid wrappers %s", args); +} + + + + +static void +handle_m (char *args, size_t len) +{ + /* 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 (is that true? I think the comment is probably + based on being confused between default buffering between + stdout and stderr. But I'm not sure). */ + fflush (stderr); + fwrite (args, sizeof *args, len, stdout); + putc ('\n', stdout); +} + + + +static void +handle_mbinary (char *args, size_t len) +{ + char *size_string; + size_t size; + size_t totalread; + size_t nread; + size_t toread; + char buf[8192]; + + /* See comment at handle_m about (non)flush of stderr. */ + + /* Get the size. */ + read_line (&size_string); + size = atoi (size_string); + free (size_string); + + /* OK, now get all the data. The algorithm here is that we read + as much as the network wants to give us in + try_read_from_server, and then we output it all, and then + repeat, until we get all the data. */ + totalread = 0; + while (totalread < size) + { + toread = size - totalread; + if (toread > sizeof buf) + toread = sizeof buf; + + nread = try_read_from_server (buf, toread); + cvs_output_binary (buf, nread); + totalread += nread; + } +} + + + +static void +handle_e (char *args, size_t len) +{ + /* 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, sizeof *args, len, stderr); + putc ('\n', stderr); +} + + + +/*ARGSUSED*/ +static void +handle_f (char *args, size_t len) +{ + fflush (stderr); +} + + + +static void +handle_mt (char *args, size_t len) +{ + char *p; + char *tag = args; + char *text; + + /* See comment at handle_m for more details. */ + fflush (stderr); + + p = strchr (args, ' '); + if (!p) + text = NULL; + else + { + *p++ = '\0'; + text = p; + } + + switch (tag[0]) + { + case '+': + if (!strcmp (tag, "+updated")) + updated_seen = 1; + else if (!strcmp (tag, "+importmergecmd")) + importmergecmd.seen = 1; + break; + case '-': + if (!strcmp (tag, "-updated")) + updated_seen = 0; + else if (!strcmp (tag, "-importmergecmd")) + { + char buf[80]; + + /* Now that we have gathered the information, we can + output the suggested merge command. */ + + if (importmergecmd.conflicts == 0 + || !importmergecmd.mergetag1 + || !importmergecmd.mergetag2 + || !importmergecmd.repository) + { + error (0, 0, + "invalid server: incomplete importmergecmd tags"); + break; + } + + if (importmergecmd.conflicts == -1) + sprintf (buf, "\nNo conflicts created by this import.\n"); + else + sprintf (buf, "\n%d conflicts created by this import.\n", + importmergecmd.conflicts); + cvs_output (buf, 0); + cvs_output ("Use the following command to help the merge:\n\n", + 0); + cvs_output ("\t", 1); + cvs_output (program_name, 0); + if (CVSroot_cmdline) + { + cvs_output (" -d ", 0); + cvs_output (CVSroot_cmdline, 0); + } + cvs_output (" checkout -j", 0); + cvs_output (importmergecmd.mergetag1, 0); + cvs_output (" -j", 0); + cvs_output (importmergecmd.mergetag2, 0); + cvs_output (" ", 1); + cvs_output (importmergecmd.repository, 0); + cvs_output ("\n\n", 0); + + /* Clear the static variables so that everything is + ready for any subsequent importmergecmd tag. */ + importmergecmd.conflicts = 0; + free (importmergecmd.mergetag1); + importmergecmd.mergetag1 = NULL; + free (importmergecmd.mergetag2); + importmergecmd.mergetag2 = NULL; + free (importmergecmd.repository); + importmergecmd.repository = NULL; + + importmergecmd.seen = 0; + } + break; + default: + if (updated_seen) + { + if (!strcmp (tag, "fname")) + { + if (updated_fname) + { + /* Output the previous message now. This can happen + if there was no Update-existing or other such + response, due to the -n global option. */ + cvs_output ("U ", 0); + cvs_output (updated_fname, 0); + cvs_output ("\n", 1); + free (updated_fname); + } + updated_fname = xstrdup (text); + } + /* Swallow all other tags. Either they are extraneous + or they reflect future extensions that we can + safely ignore. */ + } + else if (importmergecmd.seen) + { + if (!strcmp (tag, "conflicts")) + { + if (!strcmp (text, "No")) + importmergecmd.conflicts = -1; + else + importmergecmd.conflicts = atoi (text); + } + else if (!strcmp (tag, "mergetag1")) + importmergecmd.mergetag1 = xstrdup (text); + else if (!strcmp (tag, "mergetag2")) + importmergecmd.mergetag2 = xstrdup (text); + else if (!strcmp (tag, "repository")) + importmergecmd.repository = xstrdup (text); + /* Swallow all other tags. Either they are text for + which we are going to print our own version when we + see -importmergecmd, or they are future extensions + we can safely ignore. */ + } + else if (!strcmp (tag, "newline")) + printf ("\n"); + else if (!strcmp (tag, "date")) + { + char *date = format_date_alloc (text); + printf ("%s", date); + free (date); + } + else if (text) + printf ("%s", text); + } +} + + + +#endif /* CLIENT_SUPPORT */ +#if defined(CLIENT_SUPPORT) || defined(SERVER_SUPPORT) + +/* This table must be writeable if the server code is included. */ +struct response responses[] = +{ +#ifdef CLIENT_SUPPORT +#define RSP_LINE(n, f, t, s) {n, f, t, s} +#else /* ! CLIENT_SUPPORT */ +#define RSP_LINE(n, f, t, s) {n, s} +#endif /* CLIENT_SUPPORT */ + + RSP_LINE("ok", handle_ok, response_type_ok, rs_essential), + RSP_LINE("error", handle_error, response_type_error, rs_essential), + RSP_LINE("Valid-requests", handle_valid_requests, response_type_normal, + rs_essential), + RSP_LINE("Force-gzip", handle_force_gzip, response_type_normal, + rs_optional), + RSP_LINE("Referrer", handle_referrer, response_type_normal, rs_optional), + RSP_LINE("Redirect", handle_redirect, response_type_redirect, rs_optional), + RSP_LINE("Checked-in", handle_checked_in, response_type_normal, + rs_essential), + RSP_LINE("New-entry", handle_new_entry, response_type_normal, rs_optional), + 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("Mod-time", handle_mod_time, 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, + rs_optional), + RSP_LINE("Set-static-directory", handle_set_static_directory, + response_type_normal, + rs_optional), + RSP_LINE("Clear-static-directory", handle_clear_static_directory, + response_type_normal, + rs_optional), + RSP_LINE("Set-sticky", handle_set_sticky, response_type_normal, + rs_optional), + RSP_LINE("Clear-sticky", handle_clear_sticky, response_type_normal, + rs_optional), + RSP_LINE("Edit-file", handle_edit_file, response_type_normal, + rs_optional), + RSP_LINE("Template", handle_template, response_type_normal, + rs_optional), + RSP_LINE("Clear-template", handle_clear_template, response_type_normal, + rs_optional), + RSP_LINE("Notified", handle_notified, response_type_normal, rs_optional), + RSP_LINE("Module-expansion", handle_module_expansion, response_type_normal, + rs_optional), + RSP_LINE("Wrapper-rcsOption", handle_wrapper_rcs_option, + response_type_normal, + rs_optional), + RSP_LINE("M", handle_m, response_type_normal, rs_essential), + RSP_LINE("Mbinary", handle_mbinary, response_type_normal, rs_optional), + RSP_LINE("E", handle_e, response_type_normal, rs_essential), + RSP_LINE("F", handle_f, response_type_normal, rs_optional), + RSP_LINE("MT", handle_mt, response_type_normal, rs_optional), + /* Possibly should be response_type_error. */ + RSP_LINE(NULL, NULL, response_type_normal, rs_essential) + +#undef RSP_LINE +}; + +#endif /* CLIENT_SUPPORT or SERVER_SUPPORT */ +#ifdef CLIENT_SUPPORT + + + +/* + * If LEN is 0, then send_to_server_via() computes string's length itself. + * + * Therefore, pass the real length when transmitting data that might + * contain 0's. + */ +void +send_to_server_via (struct buffer *via_buffer, const char *str, size_t len) +{ + static int nbytes; + + if (len == 0) + len = strlen (str); + + buf_output (via_buffer, str, len); + + /* 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 (via_buffer); + if (status != 0) + error (1, status, "error writing to server"); + nbytes = 0; + } +} + + + +void +send_to_server (const char *str, size_t len) +{ + send_to_server_via (global_to_server, str, len); +} + + + +/* 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( char *buf, size_t len ) +{ + int status; + size_t nread; + char *data; + + status = buf_read_data (global_from_server, len, &data, &nread); + if (status != 0) + { + 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"); + } + + memcpy (buf, data, nread); + + return nread; +} + + + +/* + * Read LEN bytes from the server or die trying. + */ +void +read_from_server (char *buf, size_t len) +{ + size_t red = 0; + while (red < len) + { + red += try_read_from_server (buf + red, len - red); + if (red == len) + break; + } +} + + + +/* Get some server responses and process them. + * + * RETURNS + * 0 Success + * 1 Error + * 2 Redirect + */ +int +get_server_responses (void) +{ + struct response *rs; + do + { + char *cmd; + size_t len; + + len = read_line (&cmd); + for (rs = responses; rs->name; ++rs) + if (!strncmp (cmd, rs->name, strlen (rs->name))) + { + size_t cmdlen = strlen (rs->name); + if (cmd[cmdlen] == '\0') + ; + else if (cmd[cmdlen] == ' ') + ++cmdlen; + else + /* + * The first len characters match, but it's a different + * response. e.g. the response is "oklahoma" but we + * matched "ok". + */ + continue; + (*rs->func) (cmd + cmdlen, len - cmdlen); + break; + } + if (!rs->name) + /* It's OK to print just to the first '\0'. */ + /* We might want to handle control characters and the like + in some other way other than just sending them to stdout. + One common reason for this error is if people use :ext: + with a version of rsh which is doing CRLF translation or + something, and so the client gets "ok^M" instead of "ok". + Right now that will tend to print part of this error + message over the other part of it. It seems like we could + do better (either in general, by quoting or omitting all + control characters, and/or specifically, by detecting the CRLF + case and printing a specific error message). */ + error (0, 0, + "warning: unrecognized response `%s' from cvs server", + cmd); + free (cmd); + } while (rs->type == response_type_normal); + + if (updated_fname) + { + /* Output the previous message now. This can happen + if there was no Update-existing or other such + response, due to the -n global option. */ + cvs_output ("U ", 0); + cvs_output (updated_fname, 0); + cvs_output ("\n", 1); + free (updated_fname); + updated_fname = NULL; + } + + if (rs->type == response_type_redirect) return 2; + if (rs->type == response_type_error) return 1; + if (failure_exit) return 1; + return 0; +} + + + +static inline void +close_connection_to_server (struct buffer **to, struct buffer **from) +{ + int status; + + /* First we shut down GLOBAL_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 GLOBAL_FROM_SERVER will complete. + */ + + TRACE (TRACE_FUNCTION, "close_connection_to_server ()"); + + status = buf_shutdown (*to); + if (status != 0) + error (0, status, "shutting down buffer to server"); + buf_free (*to); + *to = NULL; + + status = buf_shutdown (*from); + if (status != 0) + error (0, status, "shutting down buffer from server"); + buf_free (*from); + *from = NULL; +} + + + +/* Get the responses and then close the connection. */ + +/* + * Flag var; we'll set it in start_server() and not one of its + * callees, such as start_rsh_server(). This means that there might + * be a small window between the starting of the server and the + * setting of this var, but all the code in that window shouldn't care + * because it's busy checking return values to see if the server got + * started successfully anyway. + */ +int server_started = 0; + +int +get_responses_and_close (void) +{ + int errs = get_server_responses (); + + /* The following is necessary when working with multiple cvsroots, at least + * with commit. It used to be buried nicely in do_deferred_progs() before + * that function was removed. I suspect it wouldn't be necessary if + * call_in_directory() saved its working directory via save_cwd() before + * changing its directory and restored the saved working directory via + * restore_cwd() before exiting. Of course, calling CVS_CHDIR only once, + * here, may be more efficient. + */ + if (toplevel_wd) + { + if (CVS_CHDIR (toplevel_wd) < 0) + error (1, errno, "could not chdir to %s", toplevel_wd); + } + + if (client_prune_dirs) + process_prune_candidates (); + + close_connection_to_server (&global_to_server, &global_from_server); + server_started = 0; + + /* see if we need to sleep before returning to avoid time-stamp races */ + if (last_register_time) + sleep_past (last_register_time); + + return errs; +} + + + +bool +supported_request (const char *name) +{ + struct request *rq; + + for (rq = requests; rq->name; rq++) + if (!strcmp (rq->name, name)) + return (rq->flags & RQ_SUPPORTED) != 0; + error (1, 0, "internal error: testing support for unknown request?"); + /* NOTREACHED */ + return 0; +} + + + +#if defined (AUTH_CLIENT_SUPPORT) || defined (SERVER_SUPPORT) || defined (HAVE_KERBEROS) || defined (HAVE_GSSAPI) + + +/* Generic function to do port number lookup tasks. + * + * In order of precedence, will return: + * getenv (envname), if defined + * getservbyname (portname), if defined + * defaultport + */ +static int +get_port_number (const char *envname, const char *portname, int defaultport) +{ + struct servent *s; + char *port_s; + + if (envname && (port_s = getenv (envname))) + { + int port = atoi (port_s); + if (port <= 0) + { + error (0, 0, "%s must be a positive integer! If you", envname); + 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."); + } + return port; + } + else if (portname && (s = getservbyname (portname, "tcp"))) + return ntohs (s->s_port); + else + return defaultport; +} + + + +/* get the port number for a client to connect to based on the port + * and method of a cvsroot_t. + * + * we do this here instead of in parse_cvsroot so that we can keep network + * code confined to a localized area and also to delay the lookup until the + * last possible moment so it remains possible to run cvs client commands that + * skip opening connections to the server (i.e. skip network operations + * entirely) + * + * and yes, I know none of the commands do that now, but here's to planning + * for the future, eh? cheers. + */ +int +get_cvs_port_number (const cvsroot_t *root) +{ + + if (root->port) return root->port; + + switch (root->method) + { +# ifdef HAVE_GSSAPI + case gserver_method: +# endif /* HAVE_GSSAPI */ +# ifdef AUTH_CLIENT_SUPPORT + case pserver_method: +# endif /* AUTH_CLIENT_SUPPORT */ +# if defined (AUTH_CLIENT_SUPPORT) || defined (HAVE_GSSAPI) + return get_port_number ("CVS_CLIENT_PORT", "cvspserver", + CVS_AUTH_PORT); +# endif /* defined (AUTH_CLIENT_SUPPORT) || defined (HAVE_GSSAPI) */ +# ifdef HAVE_KERBEROS + case kserver_method: + return get_port_number ("CVS_CLIENT_PORT", "cvs", CVS_PORT); +# endif /* HAVE_KERBEROS */ + default: + error(1, EINVAL, +"internal error: get_cvs_port_number called for invalid connection method (%s)", + method_names[root->method]); + break; + } + /* NOTREACHED */ + return -1; +} + + + +/* get the port number for a client to connect to based on the proxy port + * of a cvsroot_t. + */ +static int +get_proxy_port_number (const cvsroot_t *root) +{ + + if (root->proxy_port) return root->proxy_port; + + return get_port_number ("CVS_PROXY_PORT", NULL, CVS_PROXY_PORT); +} + + + +void +make_bufs_from_fds(int tofd, int fromfd, int child_pid, cvsroot_t *root, + struct buffer **to_server_p, + struct buffer **from_server_p, int is_sock) +{ +# ifdef NO_SOCKET_TO_FD + if (is_sock) + { + assert (tofd == fromfd); + *to_server_p = socket_buffer_initialize (tofd, 0, NULL); + *from_server_p = socket_buffer_initialize (tofd, 1, NULL); + } + else +# endif /* NO_SOCKET_TO_FD */ + { + /* todo: some OS's don't need these calls... */ + close_on_exec (tofd); + close_on_exec (fromfd); + + /* SCO 3 and AIX have a nasty bug in the I/O libraries which precludes + fdopening the same file descriptor twice, so dup it if it is the + same. */ + if (tofd == fromfd) + { + fromfd = dup (tofd); + if (fromfd < 0) + error (1, errno, "cannot dup net connection"); + } + + /* These will use binary mode on systems which have it. */ + /* + * Also, we know that from_server is shut down second, so we pass + * child_pid in there. In theory, it should be stored in both + * buffers with a ref count... + */ + *to_server_p = fd_buffer_initialize (tofd, 0, root, false, NULL); + *from_server_p = fd_buffer_initialize (fromfd, child_pid, root, + true, NULL); + } +} +#endif /* defined (AUTH_CLIENT_SUPPORT) || defined (SERVER_SUPPORT) || defined (HAVE_KERBEROS) || defined(HAVE_GSSAPI) */ + + + +#if defined (AUTH_CLIENT_SUPPORT) || defined(HAVE_GSSAPI) +/* Connect to the authenticating server. + + If VERIFY_ONLY is non-zero, then just verify that the password is + correct and then shutdown the connection. + + If VERIFY_ONLY is 0, then really connect to the server. + + If DO_GSSAPI is non-zero, then we use GSSAPI authentication rather + than the pserver password authentication. + + If we fail to connect or if access is denied, then die with fatal + error. */ +void +connect_to_pserver (cvsroot_t *root, struct buffer **to_server_p, + struct buffer **from_server_p, int verify_only, + int do_gssapi) +{ + int sock; + int port_number, + proxy_port_number = 0; /* Initialize to silence -Wall. Dumb. */ + union sai { + struct sockaddr_in addr_in; + struct sockaddr addr; + } client_sai; + struct hostent *hostinfo; + struct buffer *to_server, *from_server; + + sock = socket (AF_INET, SOCK_STREAM, 0); + if (sock == -1) + error (1, 0, "cannot create socket: %s", SOCK_STRERROR (SOCK_ERRNO)); + port_number = get_cvs_port_number (root); + + /* if we have a proxy connect to that instead */ + if (root->proxy_hostname) + { + proxy_port_number = get_proxy_port_number (root); + hostinfo = init_sockaddr (&client_sai.addr_in, root->proxy_hostname, + proxy_port_number); + TRACE (TRACE_FUNCTION, "Connecting to %s:%d via proxy %s(%s):%d.", + root->hostname, port_number, root->proxy_hostname, + inet_ntoa (client_sai.addr_in.sin_addr), proxy_port_number); + } + else + { + hostinfo = init_sockaddr (&client_sai.addr_in, root->hostname, + port_number); + TRACE (TRACE_FUNCTION, "Connecting to %s(%s):%d.", + root->hostname, + inet_ntoa (client_sai.addr_in.sin_addr), port_number); + } + + if (connect (sock, &client_sai.addr, sizeof (client_sai)) + < 0) + error (1, 0, "connect to %s(%s):%d failed: %s", + root->proxy_hostname ? root->proxy_hostname : root->hostname, + inet_ntoa (client_sai.addr_in.sin_addr), + root->proxy_hostname ? proxy_port_number : port_number, + SOCK_STRERROR (SOCK_ERRNO)); + + make_bufs_from_fds (sock, sock, 0, root, &to_server, &from_server, 1); + + /* if we have proxy then connect to the proxy first */ + if (root->proxy_hostname) + { +#define CONNECT_STRING "CONNECT %s:%d HTTP/1.0\r\n\r\n" + /* Send a "CONNECT" command to proxy: */ + char* read_buf; + int codenum; + size_t count; + /* 4 characters for port covered by the length of %s & %d */ + char* write_buf = Xasnprintf (NULL, &count, CONNECT_STRING, + root->hostname, port_number); + send_to_server_via (to_server, write_buf, count); + + /* Wait for HTTP status code, bail out if you don't get back a 2xx + * code. + */ + read_line_via (from_server, to_server, &read_buf); + sscanf (read_buf, "%s %d", write_buf, &codenum); + + if ((codenum / 100) != 2) + error (1, 0, "proxy server %s:%d does not support http tunnelling", + root->proxy_hostname, proxy_port_number); + free (read_buf); + free (write_buf); + + /* Skip through remaining part of MIME header, recv_line + consumes the trailing \n */ + while (read_line_via (from_server, to_server, &read_buf) > 0) + { + if (read_buf[0] == '\r' || read_buf[0] == 0) + { + free (read_buf); + break; + } + free (read_buf); + } + } + + auth_server (root, to_server, from_server, verify_only, do_gssapi, + hostinfo); + + if (verify_only) + { + int status; + + status = buf_shutdown (to_server); + if (status != 0) + error (0, status, "shutting down buffer to server"); + buf_free (to_server); + to_server = NULL; + + status = buf_shutdown (from_server); + if (status != 0) + error (0, status, "shutting down buffer from server"); + buf_free (from_server); + from_server = NULL; + + /* Don't need to set server_started = 0 since we don't set it to 1 + * until returning from this call. + */ + } + else + { + *to_server_p = to_server; + *from_server_p = from_server; + } + + return; +} + + + +static void +auth_server (cvsroot_t *root, struct buffer *to_server, + struct buffer *from_server, int verify_only, int do_gssapi, + struct hostent *hostinfo) +{ + char *username = NULL; /* the username we use to connect */ + char no_passwd = 0; /* gets set if no password found */ + + /* Run the authorization mini-protocol before anything else. */ + if (do_gssapi) + { +# ifdef HAVE_GSSAPI + int fd = buf_get_fd (to_server); + struct stat s; + + if ((fd < 0) || (fstat (fd, &s) < 0) || !S_ISSOCK(s.st_mode)) + { + error (1, 0, + "gserver currently only enabled for socket connections"); + } + + if (! connect_to_gserver (root, fd, hostinfo)) + { + error (1, 0, + "authorization failed: server %s rejected access to %s", + root->hostname, root->directory); + } +# else /* ! HAVE_GSSAPI */ + error (1, 0, +"INTERNAL ERROR: This client does not support GSSAPI authentication"); +# endif /* HAVE_GSSAPI */ + } + else /* ! do_gssapi */ + { +# ifdef AUTH_CLIENT_SUPPORT + char *begin = NULL; + char *password = NULL; + char *end = NULL; + + if (verify_only) + { + begin = "BEGIN VERIFICATION REQUEST"; + end = "END VERIFICATION REQUEST"; + } + else + { + begin = "BEGIN AUTH REQUEST"; + end = "END AUTH REQUEST"; + } + + /* Get the password, probably from ~/.cvspass. */ + password = get_cvs_password (); + username = root->username ? root->username : getcaller(); + + /* Send the empty string by default. This is so anonymous CVS + access doesn't require client to have done "cvs login". */ + if (!password) + { + no_passwd = 1; + password = scramble (""); + } + + /* Announce that we're starting the authorization protocol. */ + send_to_server_via(to_server, begin, 0); + send_to_server_via(to_server, "\012", 1); + + /* Send the data the server needs. */ + send_to_server_via(to_server, root->directory, 0); + send_to_server_via(to_server, "\012", 1); + send_to_server_via(to_server, username, 0); + send_to_server_via(to_server, "\012", 1); + send_to_server_via(to_server, password, 0); + send_to_server_via(to_server, "\012", 1); + + /* Announce that we're ending the authorization protocol. */ + send_to_server_via(to_server, end, 0); + send_to_server_via(to_server, "\012", 1); + + /* Paranoia. */ + memset (password, 0, strlen (password)); +# else /* ! AUTH_CLIENT_SUPPORT */ + error (1, 0, "INTERNAL ERROR: This client does not support pserver authentication"); +# endif /* AUTH_CLIENT_SUPPORT */ + } /* if (do_gssapi) */ + + { + char *read_buf; + + /* Loop, getting responses from the server. */ + while (1) + { + read_line_via (from_server, to_server, &read_buf); + + if (!strcmp (read_buf, "I HATE YOU")) + { + /* Authorization not granted. + * + * This is a little confusing since we can reach this while + * loop in GSSAPI mode, but if GSSAPI authentication failed, + * we already jumped to the rejected label (there is no case + * where the connect_to_gserver function can return 1 and we + * will not receive "I LOVE YOU" from the server, barring + * broken connections and garbled messages, of course). The + * GSSAPI case is also the case where username can be NULL + * since username is initialized in the !gssapi section. + * + * i.e. This is a pserver specific error message and should be + * since GSSAPI doesn't use username. + */ + error (0, 0, +"authorization failed: server %s rejected access to %s for user %s", + root->hostname, root->directory, + username ? username : "(null)"); + + /* Output a special error message if authentication was attempted + with no password -- the user should be made aware that they may + have missed a step. */ + if (no_passwd) + { + error (0, 0, +"used empty password; try \"cvs login\" with a real password"); + } + exit (EXIT_FAILURE); + } + else if (!strncmp (read_buf, "E ", 2)) + { + fprintf (stderr, "%s\n", read_buf + 2); + + /* Continue with the authentication protocol. */ + } + else if (!strncmp (read_buf, "error ", 6)) + { + char *p; + + /* First skip the code. */ + p = read_buf + 6; + while (*p != ' ' && *p != '\0') + ++p; + + /* Skip the space that follows the code. */ + if (*p == ' ') + ++p; + + /* Now output the text. */ + fprintf (stderr, "%s\n", p); + exit (EXIT_FAILURE); + } + else if (!strcmp (read_buf, "I LOVE YOU")) + { + free (read_buf); + break; + } + else + { + error (1, 0, + "unrecognized auth response from %s: %s", + root->hostname, read_buf); + } + free (read_buf); + } + } +} +#endif /* defined (AUTH_CLIENT_SUPPORT) || defined(HAVE_GSSAPI) */ + + + +#if defined (CLIENT_SUPPORT) || defined (SERVER_SUPPORT) +/* + * Connect to a forked server process. + */ +static void +connect_to_forked_server (cvsroot_t *root, struct buffer **to_server_p, + struct buffer **from_server_p) +{ + int tofd, fromfd; + int child_pid; + + /* This is pretty simple. All we need to do is choose the correct + cvs binary and call piped_child. */ + + char *command[3]; + + command[0] = (root->cvs_server + ? root->cvs_server : getenv ("CVS_SERVER")); + if (!command[0]) +# ifdef SERVER_SUPPORT + /* FIXME: + * I'm casting out the const below because I know that piped_child, the + * only function we pass COMMAND to, accepts COMMAND as a + * (char *const *) and won't alter it, and we don't alter it in this + * function. This is yucky, there should be a way to declare COMMAND + * such that this casting isn't needed, but I don't know how. If I + * declare it as (const char *command[]), the compiler complains about + * an incompatible arg 1 being passed to piped_child and if I declare + * it as (char *const command[3]), then the compiler complains when I + * assign values to command[i]. + */ + command[0] = (char *)program_path; +# else /* SERVER_SUPPORT */ + { + error( 0, 0, "You must set the CVS_SERVER environment variable when" ); + error( 0, 0, "using the :fork: access method." ); + error( 1, 0, "This CVS was not compiled with server support." ); + } +# endif /* SERVER_SUPPORT */ + + command[1] = "server"; + command[2] = NULL; + + TRACE (TRACE_FUNCTION, "Forking server: %s %s", + command[0] ? command[0] : "(null)", command[1]); + + child_pid = piped_child (command, &tofd, &fromfd, false); + if (child_pid < 0) + error (1, 0, "could not fork server process"); + + make_bufs_from_fds (tofd, fromfd, child_pid, root, to_server_p, + from_server_p, 0); +} +#endif /* CLIENT_SUPPORT || SERVER_SUPPORT */ + + + +static int +send_variable_proc (Node *node, void *closure) +{ + send_to_server ("Set ", 0); + send_to_server (node->key, 0); + send_to_server ("=", 1); + send_to_server (node->data, 0); + send_to_server ("\012", 1); + return 0; +} + + + +/* Open up the connection to the server and perform any necessary + * authentication. + */ +void +open_connection_to_server (cvsroot_t *root, struct buffer **to_server_p, + struct buffer **from_server_p) +{ + /* 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. */ + + TRACE (TRACE_FUNCTION, "open_connection_to_server (%s)", root->original); + + switch (root->method) + { + case pserver_method: +#ifdef AUTH_CLIENT_SUPPORT + /* Toss the return value. It will die with an error message if + * anything goes wrong anyway. + */ + connect_to_pserver (root, to_server_p, from_server_p, 0, 0); +#else /* AUTH_CLIENT_SUPPORT */ + error (0, 0, "CVSROOT is set for a pserver access method but your"); + error (1, 0, "CVS executable doesn't support it."); +#endif /* AUTH_CLIENT_SUPPORT */ + break; + + case kserver_method: +#if HAVE_KERBEROS + start_kerberos4_server (root, to_server_p, + from_server_p); +#else /* !HAVE_KERBEROS */ + error (0, 0, + "CVSROOT is set for a kerberos access method but your"); + error (1, 0, "CVS executable doesn't support it."); +#endif /* HAVE_KERBEROS */ + break; + + case gserver_method: +#ifdef HAVE_GSSAPI + /* GSSAPI authentication is handled by the pserver. */ + connect_to_pserver (root, to_server_p, from_server_p, 0, 1); +#else /* !HAVE_GSSAPI */ + error (0, 0, "CVSROOT is set for a GSSAPI access method but your"); + error (1, 0, "CVS executable doesn't support it."); +#endif /* HAVE_GSSAPI */ + break; + + case ext_method: +#ifdef NO_EXT_METHOD + error (0, 0, ":ext: method not supported by this port of CVS"); + error (1, 0, "try :server: instead"); +#else /* ! NO_EXT_METHOD */ + start_rsh_server (root, to_server_p, + from_server_p); +#endif /* NO_EXT_METHOD */ + break; + + case server_method: +#ifdef START_SERVER + { + int tofd, fromfd; + START_SERVER (&tofd, &fromfd, getcaller (), + root->username, + root->hostname, + root->directory); +# ifdef START_SERVER_RETURNS_SOCKET + make_bufs_from_fds (tofd, fromfd, 0, root, to_server_p, + from_server_p, 1); +# else /* ! START_SERVER_RETURNS_SOCKET */ + make_bufs_from_fds (tofd, fromfd, 0, root, to_server_p, + from_server_p, 0); +# endif /* START_SERVER_RETURNS_SOCKET */ + } +#else /* ! START_SERVER */ + /* 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 /* START_SERVER */ + break; + + case fork_method: + connect_to_forked_server (root, to_server_p, from_server_p); + break; + + 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; +} + + + +/* Contact the server. */ +void +start_server (void) +{ + bool rootless; + int status; + bool have_global; + + do + { + /* Clear our static variables for this invocation. */ + if (toplevel_repos) + free (toplevel_repos); + toplevel_repos = NULL; + + open_connection_to_server (current_parsed_root, &global_to_server, + &global_from_server); + setup_logfiles ("CVS_CLIENT_LOG", &global_to_server, + &global_from_server); + + /* Clear static variables. */ + if (toplevel_repos) + { + free (toplevel_repos); + toplevel_repos = NULL; + } + if (last_repos) + { + free (last_repos); + last_repos = NULL; + } + if (last_update_dir) + { + free (last_update_dir); + last_update_dir = NULL; + } + stored_checksum_valid = 0; + if (stored_mode) + { + free (stored_mode); + stored_mode = NULL; + } + + rootless = !strcmp (cvs_cmd_name, "init"); + if (!rootless) + { + send_to_server ("Root ", 0); + send_to_server (current_parsed_root->directory, 0); + send_to_server ("\012", 1); + } + + { + struct response *rs; + bool suppress_redirect = !current_parsed_root->redirect; + + send_to_server ("Valid-responses", 0); + + for (rs = responses; rs->name; ++rs) + { + if (suppress_redirect && !strcmp (rs->name, "Redirect")) + continue; + + send_to_server (" ", 0); + send_to_server (rs->name, 0); + } + send_to_server ("\012", 1); + } + send_to_server ("valid-requests\012", 0); + + if (get_server_responses ()) + exit (EXIT_FAILURE); + + have_global = supported_request ("Global_option"); + + /* Encryption needs to come before compression. Good encryption can + * render compression useless in the other direction. + */ + if (cvsencrypt && !rootless) + { +#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 (current_parsed_root->method == kserver_method) + { + if (!supported_request ("Kerberos-encrypt")) + error (1, 0, "This server does not support encryption"); + send_to_server ("Kerberos-encrypt\012", 0); + initialize_kerberos4_encryption_buffers (&global_to_server, + &global_from_server); + } + else +# endif /* HAVE_KERBEROS */ +# ifdef HAVE_GSSAPI + if (current_parsed_root->method == gserver_method) + { + if (!supported_request ("Gssapi-encrypt")) + error (1, 0, "This server does not support encryption"); + send_to_server ("Gssapi-encrypt\012", 0); + initialize_gssapi_buffers (&global_to_server, + &global_from_server); + cvs_gssapi_encrypt = 1; + } + else +# endif /* HAVE_GSSAPI */ + error (1, 0, +"Encryption is only supported when using GSSAPI or Kerberos"); +#else /* ! ENCRYPTION */ + error (1, 0, "This client does not support encryption"); +#endif /* ! ENCRYPTION */ + } + + /* Send this before compression to enable supression of the + * "Forcing compression level Z" messages. + */ + if (quiet) + { + if (have_global) + { + send_to_server ("Global_option -q\012", 0); + } + else + error (1, 0, + "This server does not support the global -q option."); + } + if (really_quiet) + { + if (have_global) + { + send_to_server ("Global_option -Q\012", 0); + } + else + error (1, 0, + "This server does not support the global -Q option."); + } + + /* Compression needs to come before any of the rooted requests to + * work with compression limits. + */ + if (!rootless && (gzip_level || force_gzip)) + { + if (supported_request ("Gzip-stream")) + { + char *gzip_level_buf = Xasprintf ("%d", gzip_level); + send_to_server ("Gzip-stream ", 0); + send_to_server (gzip_level_buf, 0); + free (gzip_level_buf); + send_to_server ("\012", 1); + + /* All further communication with the server will be + compressed. */ + + global_to_server = + compress_buffer_initialize (global_to_server, 0, + gzip_level, NULL); + global_from_server = + compress_buffer_initialize (global_from_server, 1, + gzip_level, NULL); + } +#ifndef NO_CLIENT_GZIP_PROCESS + else if (supported_request ("gzip-file-contents")) + { + char *gzip_level_buf = Xasprintf ("%d", gzip_level); + send_to_server ("gzip-file-contents ", 0); + send_to_server (gzip_level_buf, 0); + free (gzip_level_buf); + 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; + } + } + + if (client_referrer && supported_request ("Referrer")) + { + send_to_server ("Referrer ", 0); + send_to_server (client_referrer->original, 0); + send_to_server ("\012", 0); + } + + /* FIXME: I think we should still be sending this for init. */ + if (!rootless && supported_request ("Command-prep")) + { + send_to_server ("Command-prep ", 0); + send_to_server (cvs_cmd_name, 0); + send_to_server ("\012", 0); + status = get_server_responses (); + if (status == 1) exit (EXIT_FAILURE); + if (status == 2) close_connection_to_server (&global_to_server, + &global_from_server); + } + else status = 0; + } while (status == 2); + + + /* + * Now handle global options. + * + * -H, -f, -d, -e should be handled OK locally. + * + * -b we ignore (treating it as a server installation issue). + * FIXME: should be an error message. + * + * -v we print local version info; FIXME: Add a protocol request to get + * the version from the server so we can print that too. + * + * -l -t -r -w -q -n and -Q need to go to the server. + */ + if (noexec) + { + if (have_global) + { + send_to_server ("Global_option -n\012", 0); + } + else + error (1, 0, + "This server does not support the global -n option."); + } + if (!cvswrite) + { + if (have_global) + { + send_to_server ("Global_option -r\012", 0); + } + else + error (1, 0, + "This server does not support the global -r option."); + } + if (trace) + { + if (have_global) + { + int count = trace; + while (count--) send_to_server ("Global_option -t\012", 0); + } + else + error (1, 0, + "This server does not support the global -t option."); + } + + /* Find out about server-side cvswrappers. An extra network + turnaround for cvs import seems to be unavoidable, unless we + want to add some kind of client-side place to configure which + filenames imply binary. For cvs add, we could avoid the + problem by keeping a copy of the wrappers in CVSADM (the main + reason to bother would be so we could make add work without + contacting the server, I suspect). */ + + if (!strcmp (cvs_cmd_name, "import") || !strcmp (cvs_cmd_name, "add")) + { + if (supported_request ("wrapper-sendme-rcsOptions")) + { + int err; + send_to_server ("wrapper-sendme-rcsOptions\012", 0); + err = get_server_responses (); + if (err != 0) + error (err, 0, "error reading from server"); + } + } + + if (cvsauthenticate && ! cvsencrypt && !rootless) + { + /* Turn on authentication after turning on compression, so + that we can compress the authentication information. We + assume that encrypted data is always authenticated--the + ability to decrypt the data stream is itself a form of + authentication. */ +#ifdef HAVE_GSSAPI + if (current_parsed_root->method == gserver_method) + { + if (! supported_request ("Gssapi-authenticate")) + error (1, 0, + "This server does not support stream authentication"); + send_to_server ("Gssapi-authenticate\012", 0); + initialize_gssapi_buffers(&global_to_server, &global_from_server); + + } + else + error (1, 0, "Stream authentication is only supported when using GSSAPI"); +#else /* ! HAVE_GSSAPI */ + error (1, 0, "This client does not support stream authentication"); +#endif /* ! HAVE_GSSAPI */ + } + + /* If "Set" is not supported, just silently fail to send the variables. + Users with an old server should get a useful error message when it + fails to recognize the ${=foo} syntax. This way if someone uses + several servers, some of which are new and some old, they can still + set user variables in their .cvsrc without trouble. */ + if (supported_request ("Set")) + walklist (variable_list, send_variable_proc, NULL); +} + + + +/* Send an argument STRING. */ +void +send_arg (const char *string) +{ + const char *p = string; + + send_to_server ("Argument ", 0); + + while (*p) + { + if (*p == '\n') + send_to_server ("\012Argumentx ", 0); + else + send_to_server (p, 1); + ++p; + } + send_to_server ("\012", 1); +} + + + +/* 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 (const char *file, const char *short_pathname, Vers_TS *vers) +{ + /* File was modified, send it. */ + struct stat sb; + int fd; + unsigned char *buf; + char *mode_string; + size_t bufsize; + int bin; + + TRACE (TRACE_FUNCTION, "Sending file `%s' to server", file); + + /* Don't think we can assume fstat exists. */ + if (stat (file, &sb) < 0) + error (1, errno, "reading %s", short_pathname); + + mode_string = mode_to_string (sb.st_mode); + + /* Beware: on systems using CRLF line termination conventions, + the read and write functions will convert CRLF to LF, so the + number of characters read is not the same as sb.st_size. Text + files should always be transmitted using the LF convention, so + we don't want to disable this conversion. */ + bufsize = sb.st_size; + buf = xmalloc (bufsize); + + /* Is the file marked as containing binary data by the "-kb" flag? + If so, make sure to open it in binary mode: */ + + if (vers && vers->options) + bin = !strcmp (vers->options, "-kb"); + else + bin = 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 = Xasprintf ("%s.CVSBFCTMP", file); + 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); + free (tfile); + } + 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 (file_gzip_level && sb.st_size > 100) + { + size_t newsize = 0; + + if (read_and_gzip (fd, short_pathname, &buf, + &bufsize, &newsize, + file_gzip_level)) + error (1, 0, "aborting due to compression error"); + + if (close (fd) < 0) + error (0, errno, "warning: can't close %s", short_pathname); + + { + char tmp[80]; + + send_to_server ("Modified ", 0); + send_to_server (file, 0); + send_to_server ("\012", 1); + send_to_server (mode_string, 0); + send_to_server ("\012z", 2); + sprintf (tmp, "%lu\n", (unsigned long) newsize); + send_to_server (tmp, 0); + + send_to_server (buf, newsize); + } + } + else + { + int newsize; + + { + unsigned char *bufp = buf; + int len; + + /* FIXME: This is gross. It assumes that we might read + less than st_size bytes (true on NT), but not more. + Instead of this we should just be reading a block of + data (e.g. 8192 bytes), writing it to the network, and + so on until EOF. */ + while ((len = read (fd, bufp, (buf + sb.st_size) - bufp)) > 0) + bufp += len; + + if (len < 0) + error (1, errno, "reading %s", short_pathname); + + newsize = bufp - buf; + } + if (close (fd) < 0) + error (0, errno, "warning: can't close %s", short_pathname); + + { + char tmp[80]; + + send_to_server ("Modified ", 0); + send_to_server (file, 0); + send_to_server ("\012", 1); + send_to_server (mode_string, 0); + send_to_server ("\012", 1); + sprintf (tmp, "%lu\012", (unsigned long) newsize); + send_to_server (tmp, 0); + } +#ifdef BROKEN_READWRITE_CONVERSION + if (!bin) + { + char *tfile = Xasprintf ("%s.CVSBFCTMP", file); + if (CVS_UNLINK (tfile) < 0) + error (0, errno, "warning: can't remove temp file %s", tfile); + free (tfile); + } +#endif + + /* + * Note that this only ends with a newline if the file ended with + * one. + */ + if (newsize > 0) + send_to_server (buf, newsize); + } + free (buf); + free (mode_string); +} + + + +/* 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; + int backup_modified; +}; + +/* Deal with one file. */ +static int +send_fileproc (void *callerdat, struct file_info *finfo) +{ + struct send_data *args = callerdat; + Vers_TS *vers; + struct file_info xfinfo; + /* File name to actually use. Might differ in case from + finfo->file. */ + const char *filename; + + send_a_repository ("", finfo->repository, finfo->update_dir); + + xfinfo = *finfo; + xfinfo.repository = NULL; + xfinfo.rcs = NULL; + vers = Version_TS (&xfinfo, NULL, NULL, NULL, 0, 0); + + if (vers->entdata) + filename = vers->entdata->user; + else + filename = finfo->file; + + if (vers->vn_user) + { + /* The Entries request. */ + send_to_server ("Entry /", 0); + send_to_server (filename, 0); + send_to_server ("/", 0); + send_to_server (vers->vn_user, 0); + send_to_server ("/", 0); + if (vers->ts_conflict) + { + if (vers->ts_user && !strcmp (vers->ts_conflict, vers->ts_user)) + send_to_server ("+=", 0); + else + send_to_server ("+modified", 0); + } + send_to_server ("/", 0); + send_to_server (vers->entdata ? vers->entdata->options : vers->options, + 0); + send_to_server ("/", 0); + if (vers->entdata && vers->entdata->tag) + { + send_to_server ("T", 0); + send_to_server (vers->entdata->tag, 0); + } + else if (vers->entdata && vers->entdata->date) + { + send_to_server ("D", 0); + send_to_server (vers->entdata->date, 0); + } + send_to_server ("\012", 1); + } + else + { + /* It seems a little silly to re-read this on each file, but + send_dirent_proc doesn't get called if filenames are specified + explicitly on the command line. */ + wrap_add_file (CVSDOTWRAPPER, 1); + + if (wrap_name_has (filename, WRAP_RCSOPTION)) + { + /* No "Entry", but the wrappers did give us a kopt so we better + send it with "Kopt". As far as I know this only happens + for "cvs add". Question: is there any reason why checking + for options from wrappers isn't done in Version_TS? + + Note: it might have been better to just remember all the + kopts on the client side, rather than send them to the server, + and have it send us back the same kopts. But that seemed like + a bigger change than I had in mind making now. */ + + if (supported_request ("Kopt")) + { + char *opt; + + send_to_server ("Kopt ", 0); + opt = wrap_rcsoption (filename, 1); + send_to_server (opt, 0); + send_to_server ("\012", 1); + free (opt); + } + else + error (0, 0, "\ +warning: ignoring -k options due to server limitations"); + } + } + + if (!vers->ts_user) + { + /* + * Do we want to print "file was lost" like normal CVS? + * Would it always be appropriate? + */ + /* File no longer exists. Don't do anything, missing files + just happen. */ + } + else if (!vers->ts_rcs || args->force + || strcmp (vers->ts_conflict + ? vers->ts_conflict : vers->ts_rcs, vers->ts_user) + || (vers->ts_conflict && !strcmp (cvs_cmd_name, "diff"))) + { + 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); + + if (args->backup_modified) + { + char *bakname; + bakname = backup_file (filename, vers->vn_user); + /* This behavior is sufficiently unexpected to + justify overinformativeness, I think. */ + if (! really_quiet) + printf ("(Locally modified %s moved to %s)\n", + filename, bakname); + free (bakname); + } + } + else + { + 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 */ + if (ignlist) + { + Node *p; + + p = getnode (); + p->type = FILES; + p->key = xstrdup (finfo->file); + (void) addnode (ignlist, p); + } + + freevers_ts (&vers); + return 0; +} + + + +static void +send_ignproc (const char *file, const char *dir) +{ + if (ign_inhibit_server || !supported_request ("Questionable")) + { + if (dir[0] != '\0') + (void) printf ("? %s/%s\n", dir, file); + else + (void) printf ("? %s\n", file); + } + else + { + send_to_server ("Questionable ", 0); + send_to_server (file, 0); + send_to_server ("\012", 1); + } +} + + + +static int +send_filesdoneproc (void *callerdat, int err, const char *repository, + const char *update_dir, List *entries) +{ + /* if this directory has an ignore list, process it then free it */ + if (ignlist) + { + ignore_files (ignlist, entries, update_dir, send_ignproc); + dellist (&ignlist); + } + + return err; +} + + + +/* + * send_dirent_proc () is called back by the recursion processor before a + * sub-directory is processed for update. + * A return code of 0 indicates the directory should be + * processed by the recursion code. A return of non-zero indicates the + * recursion code should skip this directory. + * + */ +static Dtype +send_dirent_proc (void *callerdat, const char *dir, const char *repository, + const char *update_dir, List *entries) +{ + struct send_data *args = callerdat; + int dir_exists; + char *cvsadm_name; + + if (ignore_directory (update_dir)) + { + /* print the warm fuzzy message */ + if (!quiet) + error (0, 0, "Ignoring %s", 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 = Xasprintf ("%s/%s", dir, CVSADM); + dir_exists = isdir (cvsadm_name); + free (cvsadm_name); + + /* + * If there is an empty directory (e.g. we are doing `cvs add' on a + * newly-created directory), the server still needs to know about it. + */ + + if (dir_exists) + { + /* + * Get the repository from a CVS/Repository file whenever possible. + * The repository variable is wrong if the names in the local + * directory don't match the names in the repository. + */ + char *repos = Name_Repository (dir, update_dir); + send_a_repository (dir, repos, update_dir); + free (repos); + + /* initialize the ignore list for this directory */ + ignlist = getlist (); + } + else + { + /* It doesn't make sense to send a non-existent directory, + because there is no way to get the correct value for + the repository (I suppose maybe via the expand-modules + request). In the case where the "obvious" choice for + repository is correct, the server can figure out whether + to recreate the directory; in the case where it is wrong + (that is, does not match what modules give us), we might as + well just fail to recreate it. + + Checking for noexec is a kludge for "cvs -n add 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 (args->build_dirs && noexec) + send_a_repository (dir, repository, update_dir); + } + + return dir_exists ? R_PROCESS : R_SKIP_ALL; +} + + + +/* + * send_dirleave_proc () is called back by the recursion code upon leaving + * a directory. All it does is delete the ignore list if it hasn't already + * been done (by send_filesdone_proc). + */ +/* ARGSUSED */ +static int +send_dirleave_proc (void *callerdat, const char *dir, int err, + const char *update_dir, List *entries ) +{ + + /* Delete the ignore list if it hasn't already been done. */ + if (ignlist) + dellist (&ignlist); + return err; +} + + + +/* + * Send each option in an array to the server, one by one. + * argv might be "--foo=bar", "-C", "5", "-y". + */ + +void +send_options (int argc, char * const *argv) +{ + int i; + for (i = 0; i < argc; i++) + send_arg (argv[i]); +} + + + +/* Send the names of all the argument files to the server. */ +void +send_file_names (int argc, char **argv, unsigned int flags) +{ + int i; + + /* The fact that we do this here as well as start_recursion is a bit + of a performance hit. Perhaps worth cleaning up someday. */ + if (flags & SEND_EXPAND_WILD) + expand_wild (argc, argv, &argc, &argv); + + for (i = 0; i < argc; ++i) + { + char buf[1]; + char *p; +#ifdef FILENAMES_CASE_INSENSITIVE + char *line = NULL; +#endif /* FILENAMES_CASE_INSENSITIVE */ + + if (arg_should_not_be_sent_to_server (argv[i])) + continue; + +#ifdef FILENAMES_CASE_INSENSITIVE + /* We want to send the path as it appears in the + CVS/Entries files. We put this inside an ifdef + to avoid doing all these system calls in + cases where fncmp is just strcmp anyway. */ + /* The isdir (CVSADM) 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. */ + { + List *stack; + size_t line_len = 0; + char *q, *r; + struct saved_cwd sdir; + + /* Split the argument onto the stack. */ + stack = getlist(); + r = xstrdup (argv[i]); + /* It's okay to discard the const from the last_component return + * below since we know we passed in an arg that was not const. + */ + while ((q = (char *)last_component (r)) != r) + { + push (stack, xstrdup (q)); + *--q = '\0'; + } + push (stack, r); + + /* Normalize the path into outstr. */ + save_cwd (&sdir); + while (q = pop (stack)) + { + Node *node = NULL; + if (isdir (CVSADM)) + { + List *entries; + + /* 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, NULL); + node = findnode_fn (entries, q); + if (node) + { + /* Add the slash unless this is our first element. */ + if (line_len) + xrealloc_and_strcat (&line, &line_len, "/"); + xrealloc_and_strcat (&line, &line_len, node->key); + delnode (node); + } + Entries_Close (entries); + } + + /* If node is still NULL then we either didn't find CVSADM or + * we didn't find an entry there. + */ + if (!node) + { + /* Add the slash unless this is our first element. */ + if (line_len) + xrealloc_and_strcat (&line, &line_len, "/"); + xrealloc_and_strcat (&line, &line_len, q); + break; + } + + /* And descend the tree. */ + if (isdir (q)) + CVS_CHDIR (q); + free (q); + } + restore_cwd (&sdir); + free_cwd (&sdir); + + /* Now put everything we didn't find entries for back on. */ + while (q = pop (stack)) + { + if (line_len) + xrealloc_and_strcat (&line, &line_len, "/"); + xrealloc_and_strcat (&line, &line_len, q); + free (q); + } + + p = line; + + dellist (&stack); + } +#else /* !FILENAMES_CASE_INSENSITIVE */ + p = argv[i]; +#endif /* FILENAMES_CASE_INSENSITIVE */ + + send_to_server ("Argument ", 0); + + while (*p) + { + if (*p == '\n') + { + send_to_server ("\012Argumentx ", 0); + } + else if (ISSLASH (*p)) + { + buf[0] = '/'; + send_to_server (buf, 1); + } + else + { + buf[0] = *p; + send_to_server (buf, 1); + } + ++p; + } + send_to_server ("\012", 1); +#ifdef FILENAMES_CASE_INSENSITIVE + free (line); +#endif /* FILENAMES_CASE_INSENSITIVE */ + } + + if (flags & SEND_EXPAND_WILD) + { + int i; + for (i = 0; i < argc; ++i) + free (argv[i]); + free (argv); + } +} + + + +/* Calculate and send max-dotdot to the server */ +static void +send_max_dotdot (argc, argv) + int argc; + char **argv; +{ + int i; + int level = 0; + int max_level = 0; + + /* Send Max-dotdot if needed. */ + for (i = 0; i < argc; ++i) + { + level = pathname_levels (argv[i]); + if (level > 0) + { + if (!uppaths) uppaths = getlist(); + push_string (uppaths, xstrdup (argv[i])); + } + if (level > max_level) + max_level = level; + } + + if (max_level > 0) + { + if (supported_request ("Max-dotdot")) + { + char buf[10]; + sprintf (buf, "%d", max_level); + + send_to_server ("Max-dotdot ", 0); + send_to_server (buf, 0); + send_to_server ("\012", 1); + } + else + { + error (1, 0, +"backreference in path (`..') not supported by old (pre-Max-dotdot) servers"); + } + } +} + + + +/* 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 (int argc, char **argv, int local, int aflag, unsigned int flags) +{ + struct send_data args; + int err; + + send_max_dotdot (argc, argv); + + /* + * aflag controls whether the tag/date is copied into the vers_ts. + * 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; + args.backup_modified = flags & BACKUP_MODIFIED_FILES; + err = start_recursion + (send_fileproc, send_filesdoneproc, send_dirent_proc, + send_dirleave_proc, &args, argc, argv, local, W_LOCAL, aflag, + CVS_LOCK_NONE, NULL, 0, NULL); + if (err) + exit (EXIT_FAILURE); + if (!toplevel_repos) + /* + * This happens if we are not processing any files, + * or for checkouts in directories without any existing stuff + * checked out. The following assignment is correct for the + * latter case; I don't think toplevel_repos matters for the + * former. + */ + toplevel_repos = xstrdup (current_parsed_root->directory); + send_repository ("", toplevel_repos, "."); +} + + + +void +client_import_setup (char *repository) +{ + if (!toplevel_repos) /* should always be true */ + send_a_repository ("", repository, ""); +} + + + +/* + * Process the argument import file. + */ +int +client_process_import_file (char *message, char *vfile, char *vtag, int targc, + char *targv[], char *repository, + int all_files_binary, + int modtime /* Nonzero for "import -d". */ ) +{ + char *update_dir; + char *fullname; + Vers_TS vers; + + assert (toplevel_repos); + + if (strncmp (repository, toplevel_repos, strlen (toplevel_repos))) + error (1, 0, + "internal error: pathname `%s' doesn't specify file in `%s'", + repository, toplevel_repos); + + if (!strcmp (repository, toplevel_repos)) + { + update_dir = ""; + fullname = xstrdup (vfile); + } + else + { + update_dir = repository + strlen (toplevel_repos) + 1; + + fullname = Xasprintf ("%s/%s", update_dir, vfile); + } + + send_a_repository ("", repository, update_dir); + if (all_files_binary) + vers.options = xstrdup ("-kb"); + else + vers.options = wrap_rcsoption (vfile, 1); + + if (vers.options) + { + if (supported_request ("Kopt")) + { + send_to_server ("Kopt ", 0); + send_to_server (vers.options, 0); + send_to_server ("\012", 1); + } + else + error (0, 0, + "warning: ignoring -k options due to server limitations"); + } + if (modtime) + { + if (supported_request ("Checkin-time")) + { + struct stat sb; + char *rcsdate; + char netdate[MAXDATELEN]; + + if (stat (vfile, &sb) < 0) + error (1, errno, "cannot stat %s", fullname); + rcsdate = date_from_time_t (sb.st_mtime); + date_to_internet (netdate, rcsdate); + free (rcsdate); + + send_to_server ("Checkin-time ", 0); + send_to_server (netdate, 0); + send_to_server ("\012", 1); + } + else + error (0, 0, + "warning: ignoring -d option due to server limitations"); + } + send_modified (vfile, fullname, &vers); + if (vers.options) + free (vers.options); + free (fullname); + return 0; +} + + + +void +client_import_done (void) +{ + if (!toplevel_repos) + /* + * This happens if we are not processing any files, + * or for checkouts in directories without any existing stuff + * checked out. The following assignment is correct for the + * latter case; I don't think toplevel_repos matters for the + * former. + */ + /* FIXME: "can't happen" now that we call client_import_setup + at the beginning. */ + toplevel_repos = xstrdup (current_parsed_root->directory); + send_repository ("", toplevel_repos, "."); +} + + + +void +client_notify (const char *repository, const char *update_dir, + const char *filename, int notif_type, const char *val) +{ + char buf[2]; + + send_a_repository ("", repository, update_dir); + send_to_server ("Notify ", 0); + send_to_server (filename, 0); + send_to_server ("\012", 1); + buf[0] = notif_type; + buf[1] = '\0'; + send_to_server (buf, 1); + send_to_server ("\t", 1); + send_to_server (val, 0); +} + + + +/* + * Send an option with an argument, dealing correctly with newlines in + * the argument. If ARG is NULL, forget the whole thing. + */ +void +option_with_arg (const char *option, const char *arg) +{ + if (!arg) + return; + + send_to_server ("Argument ", 0); + send_to_server (option, 0); + send_to_server ("\012", 1); + + send_arg (arg); +} + + + +/* Send a date to the server. The input DATE is in RCS format. + The time will be GMT. + + We then convert that to the format required in the protocol + (including the "-D" option) and send it. According to + cvsclient.texi, RFC 822/1123 format is preferred. */ +void +client_senddate (const char *date) +{ + char buf[MAXDATELEN]; + + date_to_internet (buf, date); + option_with_arg ("-D", buf); +} + + + +void +send_init_command (void) +{ + /* This is here because we need the current_parsed_root->directory variable. */ + send_to_server ("init ", 0); + send_to_server (current_parsed_root->directory, 0); + send_to_server ("\012", 0); +} + + + +#if defined AUTH_CLIENT_SUPPORT || defined HAVE_KERBEROS || defined HAVE_GSSAPI + +struct hostent * +init_sockaddr (struct sockaddr_in *name, 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 (shortport); + hostinfo = gethostbyname (hostname); + if (!hostinfo) + { + fprintf (stderr, "Unknown host %s.\n", hostname); + exit (EXIT_FAILURE); + } + name->sin_addr = *(struct in_addr *) hostinfo->h_addr; + return hostinfo; +} + +#endif /* defined AUTH_CLIENT_SUPPORT || defined HAVE_KERBEROS + * || defined HAVE_GSSAPI + */ + +#endif /* CLIENT_SUPPORT */ |