also add -fwrapv to CFLAGS (addresses #698908)
[alioth/cvs.git] / src / root.c
1 /*
2  * Copyright (C) 1986-2005 The Free Software Foundation, Inc.
3  *
4  * Portions Copyright (C) 1998-2005 Derek Price, Ximbiot <http://ximbiot.com>,
5  *                                  and others.
6  *
7  * Poritons Copyright (c) 1992, Mark D. Baushke
8  *
9  * You may distribute under the terms of the GNU General Public License as
10  * specified in the README file that comes with the CVS source distribution.
11  * 
12  * Name of Root
13  * 
14  * Determine the path to the CVSROOT and set "Root" accordingly.
15  */
16
17 #include "cvs.h"
18 #include <assert.h>
19 #include "getline.h"
20
21 /* Printable names for things in the current_parsed_root->method enum variable.
22    Watch out if the enum is changed in cvs.h! */
23
24 const char method_names[][16] = {
25     "undefined", "local", "server (rsh)", "pserver",
26     "kserver", "gserver", "ext", "fork"
27 };
28
29 #ifndef DEBUG
30
31 cvsroot_t *
32 Name_Root (const char *dir, const char *update_dir)
33 {
34     FILE *fpin;
35     cvsroot_t *ret;
36     const char *xupdate_dir;
37     char *root = NULL;
38     size_t root_allocated = 0;
39     char *tmp;
40     char *cvsadm;
41     char *cp;
42     int len;
43
44     TRACE (TRACE_FLOW, "Name_Root (%s, %s)",
45            dir ? dir : "(null)",
46            update_dir ? update_dir : "(null)");
47
48     if (update_dir && *update_dir)
49         xupdate_dir = update_dir;
50     else
51         xupdate_dir = ".";
52
53     if (dir != NULL)
54     {
55         cvsadm = Xasprintf ("%s/%s", dir, CVSADM);
56         tmp = Xasprintf ("%s/%s", dir, CVSADM_ROOT);
57     }
58     else
59     {
60         cvsadm = xstrdup (CVSADM);
61         tmp = xstrdup (CVSADM_ROOT);
62     }
63
64     /*
65      * Do not bother looking for a readable file if there is no cvsadm
66      * directory present.
67      *
68      * It is possible that not all repositories will have a CVS/Root
69      * file. This is ok, but the user will need to specify -d
70      * /path/name or have the environment variable CVSROOT set in
71      * order to continue.  */
72     if ((!isdir (cvsadm)) || (!isreadable (tmp)))
73     {
74         ret = NULL;
75         goto out;
76     }
77
78     /*
79      * The assumption here is that the CVS Root is always contained in the
80      * first line of the "Root" file.
81      */
82     fpin = xfopen (tmp, "r");
83
84     if ((len = getline (&root, &root_allocated, fpin)) < 0)
85     {
86         int saved_errno = errno;
87         /* FIXME: should be checking for end of file separately; errno
88            is not set in that case.  */
89         error (0, 0, "in directory %s:", xupdate_dir);
90         error (0, saved_errno, "cannot read %s", CVSADM_ROOT);
91         error (0, 0, "please correct this problem");
92         ret = NULL;
93         goto out;
94     }
95     fclose (fpin);
96     cp = root + len - 1;
97     if (*cp == '\n')
98         *cp = '\0';                     /* strip the newline */
99
100     /*
101      * root now contains a candidate for CVSroot. It must be an
102      * absolute pathname or specify a remote server.
103      */
104
105     ret = parse_cvsroot (root);
106     if (ret == NULL)
107     {
108         error (0, 0, "in directory %s:", xupdate_dir);
109         error (0, 0,
110                "ignoring %s because it does not contain a valid root.",
111                CVSADM_ROOT);
112         goto out;
113     }
114
115     if (!ret->isremote && !isdir (ret->directory))
116     {
117         error (0, 0, "in directory %s:", xupdate_dir);
118         error (0, 0,
119                "ignoring %s because it specifies a non-existent repository %s",
120                CVSADM_ROOT, root);
121         ret = NULL;
122         goto out;
123     }
124
125
126  out:
127     free (cvsadm);
128     free (tmp);
129     if (root != NULL)
130         free (root);
131     return ret;
132 }
133
134
135
136 /*
137  * Write the CVS/Root file so that the environment variable CVSROOT
138  * and/or the -d option to cvs will be validated or not necessary for
139  * future work.
140  */
141 void
142 Create_Root (const char *dir, const char *rootdir)
143 {
144     FILE *fout;
145     char *tmp;
146
147     if (noexec)
148         return;
149
150     /* record the current cvs root */
151
152     if (rootdir != NULL)
153     {
154         if (dir != NULL)
155             tmp = Xasprintf ("%s/%s", dir, CVSADM_ROOT);
156         else
157             tmp = xstrdup (CVSADM_ROOT);
158
159         fout = xfopen (tmp, "w+");
160         if (fprintf (fout, "%s\n", rootdir) < 0)
161             error (1, errno, "write to %s failed", tmp);
162         if (fclose (fout) == EOF)
163             error (1, errno, "cannot close %s", tmp);
164         free (tmp);
165     }
166 }
167
168 #endif /* ! DEBUG */
169
170
171
172 /* Translate an absolute repository string for a primary server and return it.
173  *
174  * INPUTS
175  *   root_in    The root to be translated.
176  *
177  * RETURNS
178  *   A translated string this function owns, or a pointer to the original
179  *   string passed in if no translation was necessary.
180  *
181  *   If the returned string is the translated one, it may be overwritten
182  *   by the next call to this function.
183  */
184 const char *
185 primary_root_translate (const char *root_in)
186 {
187 #ifdef PROXY_SUPPORT
188     char *translated;
189     static char *previous = NULL;
190     static size_t len;
191
192     /* This can happen, for instance, during `cvs init'.  */
193     if (!config) return root_in;
194
195     if (config->PrimaryServer
196         && !strncmp (root_in, config->PrimaryServer->directory,
197                      strlen (config->PrimaryServer->directory))
198         && (ISSLASH (root_in[strlen (config->PrimaryServer->directory)])
199             || root_in[strlen (config->PrimaryServer->directory)] == '\0')
200        )
201     {
202         translated =
203             Xasnprintf (previous, &len,
204                         "%s%s", current_parsed_root->directory,
205                         root_in + strlen (config->PrimaryServer->directory));
206         if (previous && previous != translated)
207             free (previous);
208         return previous = translated;
209     }
210 #endif
211
212     /* There is no primary root configured or it didn't match.  */
213     return root_in;
214 }
215
216
217
218 /* Translate a primary root in reverse for PATHNAMEs in responses.
219  *
220  * INPUTS
221  *   root_in    The root to be translated.
222  *
223  * RETURNS
224  *   A translated string this function owns, or a pointer to the original
225  *   string passed in if no translation was necessary.
226  *
227  *   If the returned string is the translated one, it may be overwritten
228  *   by the next call to this function.
229  */
230 const char *
231 primary_root_inverse_translate (const char *root_in)
232 {
233 #ifdef PROXY_SUPPORT
234     char *translated;
235     static char *previous = NULL;
236     static size_t len;
237
238     /* This can happen, for instance, during `cvs init'.  */
239     if (!config) return root_in;
240
241     if (config->PrimaryServer
242         && !strncmp (root_in, current_parsed_root->directory,
243                      strlen (current_parsed_root->directory))
244         && (ISSLASH (root_in[strlen (current_parsed_root->directory)])
245             || root_in[strlen (current_parsed_root->directory)] == '\0')
246        )
247     {
248         translated =
249             Xasnprintf (previous, &len,
250                         "%s%s", config->PrimaryServer->directory,
251                         root_in + strlen (current_parsed_root->directory));
252         if (previous && previous != translated)
253             free (previous);
254         return previous = translated;
255     }
256 #endif
257
258     /* There is no primary root configured or it didn't match.  */
259     return root_in;
260 }
261
262
263
264 /* The root_allow_* stuff maintains a list of valid CVSROOT
265    directories.  Then we can check against them when a remote user
266    hands us a CVSROOT directory.  */
267 static List *root_allow;
268
269 static void
270 delconfig (Node *n)
271 {
272     if (n->data) free_config (n->data);
273 }
274
275
276
277 void
278 root_allow_add (const char *arg, const char *configPath)
279 {
280     Node *n;
281
282     if (!root_allow) root_allow = getlist();
283     n = getnode();
284     n->key = xstrdup (arg);
285     n->data = parse_config (arg, configPath);
286     n->delproc = delconfig;
287     addnode (root_allow, n);
288 }
289
290 void
291 root_allow_free (void)
292 {
293     dellist (&root_allow);
294 }
295
296 int
297 root_allow_used (void)
298 {
299     return (root_allow != NULL);
300 }
301
302 bool
303 root_allow_ok (const char *arg)
304 {
305     if (!root_allow)
306     {
307         /* Probably someone upgraded from CVS before 1.9.10 to 1.9.10
308            or later without reading the documentation about
309            --allow-root.  Printing an error here doesn't disclose any
310            particularly useful information to an attacker because a
311            CVS server configured in this way won't let *anyone* in.  */
312
313         /* Note that we are called from a context where we can spit
314            back "error" rather than waiting for the next request which
315            expects responses.  */
316         printf ("\
317 error 0 Server configuration missing --allow-root in inetd.conf\n");
318         exit (EXIT_FAILURE);
319     }
320
321     if (findnode (root_allow, arg))
322         return true;
323     return false;
324 }
325
326
327
328 /* Get a config we stored in response to root_allow.
329  *
330  * RETURNS
331  *   The config associated with ARG.
332  */
333 struct config *
334 get_root_allow_config (const char *arg, const char *configPath)
335 {
336     Node *n;
337
338     TRACE (TRACE_FUNCTION, "get_root_allow_config (%s)", arg);
339
340     if (root_allow)
341         n = findnode (root_allow, arg);
342     else
343         n = NULL;
344
345     if (n) return n->data;
346     return parse_config (arg, configPath);
347 }
348
349
350
351 /* This global variable holds the global -d option.  It is NULL if -d
352    was not used, which means that we must get the CVSroot information
353    from the CVSROOT environment variable or from a CVS/Root file.  */
354 char *CVSroot_cmdline;
355
356
357
358 /* FIXME - Deglobalize this. */
359 cvsroot_t *current_parsed_root = NULL;
360 /* Used to save the original root being processed so that we can still find it
361  * in lists and the like after a `Redirect' response.  Also set to mirror
362  * current_parsed_root in server mode so that code which runs on both the
363  * client and server but which wants to use original data on the client can
364  * just always reference the original_parsed_root.
365  */
366 const cvsroot_t *original_parsed_root;
367
368
369 /* allocate and initialize a cvsroot_t
370  *
371  * We must initialize the strings to NULL so we know later what we should
372  * free
373  *
374  * Some of the other zeroes remain meaningful as, "never set, use default",
375  * or the like
376  */
377 /* Functions which allocate memory are not pure.  */
378 static cvsroot_t *new_cvsroot_t(void)
379     __attribute__( (__malloc__) );
380 static cvsroot_t *
381 new_cvsroot_t (void)
382 {
383     cvsroot_t *newroot;
384
385     /* gotta store it somewhere */
386     newroot = xmalloc(sizeof(cvsroot_t));
387
388     newroot->original = NULL;
389     newroot->directory = NULL;
390     newroot->method = null_method;
391     newroot->isremote = false;
392 #ifdef CLIENT_SUPPORT
393     newroot->username = NULL;
394     newroot->password = NULL;
395     newroot->hostname = NULL;
396     newroot->cvs_rsh = NULL;
397     newroot->cvs_server = NULL;
398     newroot->port = 0;
399     newroot->proxy_hostname = NULL;
400     newroot->proxy_port = 0;
401     newroot->redirect = true;   /* Advertise Redirect support */
402 #endif /* CLIENT_SUPPORT */
403
404     return newroot;
405 }
406
407
408
409 /* Dispose of a cvsroot_t and its component parts.
410  *
411  * NOTE
412  *  It is dangerous for most code to call this function since parse_cvsroot
413  *  maintains a cache of parsed roots.
414  */
415 static void
416 free_cvsroot_t (cvsroot_t *root)
417 {
418     assert (root);
419     if (root->original != NULL)
420         free (root->original);
421     if (root->directory != NULL)
422         free (root->directory);
423 #ifdef CLIENT_SUPPORT
424     if (root->username != NULL)
425         free (root->username);
426     if (root->password != NULL)
427     {
428         /* I like to be paranoid */
429         memset (root->password, 0, strlen (root->password));
430         free (root->password);
431     }
432     if (root->hostname != NULL)
433         free (root->hostname);
434     if (root->cvs_rsh != NULL)
435         free (root->cvs_rsh);
436     if (root->cvs_server != NULL)
437         free (root->cvs_server);
438     if (root->proxy_hostname != NULL)
439         free (root->proxy_hostname);
440 #endif /* CLIENT_SUPPORT */
441     free (root);
442 }
443
444
445
446 /*
447  * Parse a CVSROOT string to allocate and return a new cvsroot_t structure.
448  * Valid specifications are:
449  *
450  *      :(gserver|kserver|pserver):[[user][:password]@]host[:[port]]/path
451  *      [:(ext|server):][[user]@]host[:]/path
452  *      [:local:[e:]]/path
453  *      :fork:/path
454  *
455  * INPUTS
456  *      root_in         C String containing the CVSROOT to be parsed.
457  *
458  * RETURNS
459  *      A pointer to a newly allocated cvsroot_t structure upon success and
460  *      NULL upon failure.  The caller should never dispose of this structure,
461  *      as it is stored in a cache, but the caller may rely on it not to
462  *      change.
463  *
464  * NOTES
465  *      This would have been a lot easier to write in Perl.
466  *
467  *      Would it make sense to reimplement the root and config file parsing
468  *      gunk in Lex/Yacc?
469  *
470  * SEE ALSO
471  *      free_cvsroot_t()
472  */
473 cvsroot_t *
474 parse_cvsroot (const char *root_in)
475 {
476     cvsroot_t *newroot;                 /* the new root to be returned */
477     char *cvsroot_save;                 /* what we allocated so we can dispose
478                                          * it when finished */
479     char *cvsroot_copy, *p;             /* temporary pointers for parsing */
480 #if defined(CLIENT_SUPPORT) || defined (SERVER_SUPPORT)
481     char *q;                            /* temporary pointer for parsing */
482     char *firstslash;                   /* save where the path spec starts
483                                          * while we parse
484                                          * [[user][:password]@]host[:[port]]
485                                          */
486     int check_hostname, no_port, no_password, no_proxy;
487 #endif /* defined(CLIENT_SUPPORT) || defined (SERVER_SUPPORT) */
488     static List *cache = NULL;
489     Node *node;
490
491     assert (root_in != NULL);
492
493     /* This message is TRACE_FLOW since this function is called repeatedly by
494      * the recursion routines.
495      */
496     TRACE (TRACE_FLOW, "parse_cvsroot (%s)", root_in);
497
498     if ((node = findnode (cache, root_in)))
499         return node->data;
500
501     assert (root_in);
502
503     /* allocate some space */
504     newroot = new_cvsroot_t();
505
506     /* save the original string */
507     newroot->original = xstrdup (root_in);
508
509     /* and another copy we can munge while parsing */
510     cvsroot_save = cvsroot_copy = xstrdup (root_in);
511
512     if (*cvsroot_copy == ':')
513     {
514         char *method = ++cvsroot_copy;
515
516         /* Access method specified, as in
517          * "cvs -d :(gserver|kserver|pserver):[[user][:password]@]host[:[port]]/path",
518          * "cvs -d [:(ext|server):][[user]@]host[:]/path",
519          * "cvs -d :local:e:\path",
520          * "cvs -d :fork:/path".
521          * We need to get past that part of CVSroot before parsing the
522          * rest of it.
523          */
524
525         if (! (p = strchr (method, ':')))
526         {
527             error (0, 0, "No closing `:' on method in CVSROOT.");
528             goto error_exit;
529         }
530         *p = '\0';
531         cvsroot_copy = ++p;
532
533 #if defined (CLIENT_SUPPORT) || defined (SERVER_SUPPORT)
534         /* Look for method options, for instance, proxy, proxyport.
535          * Calling strtok again is saved until after parsing the method.
536          */
537         method = strtok (method, ";");
538         if (!method)
539             /* Could just exit now, but this keeps the error message in sync.
540              */
541             method = "";
542 #endif /* defined (CLIENT_SUPPORT) || defined (SERVER_SUPPORT) */
543
544     if (NULL == method)
545         {
546             error (0, 0, "Missing method in CVSROOT.");
547             goto error_exit;
548         }
549
550         /* Now we have an access method -- see if it's valid. */
551
552         if (!strcasecmp (method, "local"))
553             newroot->method = local_method;
554         else if (!strcasecmp (method, "pserver"))
555             newroot->method = pserver_method;
556         else if (!strcasecmp (method, "kserver"))
557             newroot->method = kserver_method;
558         else if (!strcasecmp (method, "gserver"))
559             newroot->method = gserver_method;
560         else if (!strcasecmp (method, "server"))
561             newroot->method = server_method;
562         else if (strncmp (method, "ext=", 4) == 0)
563         {
564             newroot->cvs_rsh = xstrdup(method + 4);
565             newroot->method = ext_method;
566         }
567         else if (!strcasecmp (method, "extssh"))
568         {
569             newroot->cvs_rsh = xstrdup("ssh");
570             newroot->method = extssh_method;
571         }
572         else if (!strcasecmp (method, "ext"))
573             newroot->method = ext_method;
574         else if (!strcasecmp (method, "fork"))
575             newroot->method = fork_method;
576         else
577         {
578             error (0, 0, "Unknown method (`%s') in CVSROOT.", method);
579             goto error_exit;
580         }
581
582 #if defined (CLIENT_SUPPORT) || defined (SERVER_SUPPORT)
583         /* Parse the method options, for instance, proxy, proxyport */
584         while ((p = strtok (NULL, ";")))
585         {
586             char *q = strchr (p, '=');
587             if (q == NULL)
588             {
589                 error (0, 0, "Option (`%s') has no argument in CVSROOT.",
590                        p);
591                 goto error_exit;
592             }
593
594             *q++ = '\0';
595             TRACE (TRACE_DATA, "CVSROOT option=`%s' value=`%s'", p, q);
596             if (!strcasecmp (p, "proxy"))
597             {
598                 newroot->proxy_hostname = xstrdup (q);
599             }
600             else if (!strcasecmp (p, "proxyport"))
601             {
602                 char *r = q;
603                 if (*r == '-') r++;
604                 while (*r)
605                 {
606                     if (!isdigit(*r++))
607                     {
608                         error (0, 0,
609 "CVSROOT may only specify a positive, non-zero, integer proxy port (not `%s').",
610                                q);
611                         goto error_exit;
612                     }
613                 }
614                 if ((newroot->proxy_port = atoi (q)) <= 0)
615                     error (0, 0,
616 "CVSROOT may only specify a positive, non-zero, integer proxy port (not `%s').",
617                            q);
618             }
619             else if (!strcasecmp (p, "CVS_RSH"))
620             {
621                 /* override CVS_RSH environment variable */
622                 if (newroot->method == ext_method
623                     || newroot->method == extssh_method)
624                 newroot->cvs_rsh = xstrdup (q);
625             }
626             else if (!strcasecmp (p, "CVS_SERVER"))
627             {
628                 /* override CVS_SERVER environment variable */
629                 if (newroot->method == ext_method
630                     || newroot->method == extssh_method
631                     || newroot->method == fork_method)
632                     newroot->cvs_server = xstrdup (q);
633             }
634             else if (!strcasecmp (p, "Redirect"))
635                 readBool ("CVSROOT", "Redirect", q, &newroot->redirect);
636             else
637             {
638                 error (0, 0, "Unknown option (`%s') in CVSROOT.", p);
639                 goto error_exit;
640             }
641         }
642 #endif /* defined (CLIENT_SUPPORT) || defined (SERVER_SUPPORT) */
643     }
644     else
645     {
646         /* If the method isn't specified, assume EXT_METHOD if the string looks
647            like a relative path and LOCAL_METHOD otherwise.  */
648
649         newroot->method = ((*cvsroot_copy != '/' && strchr (cvsroot_copy, '/'))
650                           ? ext_method
651                           : local_method);
652     }
653
654     /*
655      * There are a few sanity checks we can do now, only knowing the
656      * method of this root.
657      */
658
659     newroot->isremote = (newroot->method != local_method);
660
661 #if defined (CLIENT_SUPPORT) || defined (SERVER_SUPPORT)
662     if (readonlyfs && newroot->isremote && (newroot->method != ext_method)
663         && (newroot->method != extssh_method))
664         error (1, 0,
665 "Read-only repository feature unavailable with remote roots (cvsroot = %s)",
666                cvsroot_copy);
667
668     if ((newroot->method != local_method)
669         && (newroot->method != fork_method)
670        )
671     {
672         /* split the string into [[user][:password]@]host[:[port]] & /path
673          *
674          * this will allow some characters such as '@' & ':' to remain unquoted
675          * in the path portion of the spec
676          */
677         if ((p = strchr (cvsroot_copy, '/')) == NULL)
678         {
679             error (0, 0, "CVSROOT requires a path spec:");
680             error (0, 0,
681 ":(gserver|kserver|pserver):[[user][:password]@]host[:[port]]/path");
682             error (0, 0, "[:(ext|server):][[user]@]host[:]/path");
683             goto error_exit;
684         }
685         firstslash = p;         /* == NULL if '/' not in string */
686         *p = '\0';
687
688         /* Check to see if there is a username[:password] in the string. */
689         if ((p = strchr (cvsroot_copy, '@')) != NULL)
690         {
691             *p = '\0';
692             /* check for a password */
693             if ((q = strchr (cvsroot_copy, ':')) != NULL)
694             {
695                 *q = '\0';
696                 newroot->password = xstrdup (++q);
697                 /* Don't check for *newroot->password == '\0' since
698                  * a user could conceivably wish to specify a blank password
699                  *
700                  * (newroot->password == NULL means to use the
701                  * password from .cvspass)
702                  */
703             }
704
705             /* copy the username */
706             if (*cvsroot_copy != '\0')
707                 /* a blank username is impossible, so leave it NULL in that
708                  * case so we know to use the default username
709                  */
710                 newroot->username = xstrdup (cvsroot_copy);
711
712             cvsroot_copy = ++p;
713         }
714
715         /* now deal with host[:[port]] */
716
717         /* the port */
718         if ((p = strchr (cvsroot_copy, ':')) != NULL)
719         {
720             *p++ = '\0';
721             if (strlen(p))
722             {
723                 q = p;
724                 if (*q == '-') q++;
725                 while (*q)
726                 {
727                     if (!isdigit(*q++))
728                     {
729                         error (0, 0,
730 "CVSROOT may only specify a positive, non-zero, integer port (not `%s').",
731                                 p);
732                         error (0, 0,
733                                "Perhaps you entered a relative pathname?");
734                         goto error_exit;
735                     }
736                 }
737                 if ((newroot->port = atoi (p)) <= 0)
738                 {
739                     error (0, 0,
740 "CVSROOT may only specify a positive, non-zero, integer port (not `%s').",
741                             p);
742                     error (0, 0, "Perhaps you entered a relative pathname?");
743                     goto error_exit;
744                 }
745             }
746         }
747
748         /* copy host */
749         if (*cvsroot_copy != '\0')
750             /* blank hostnames are invalid, but for now leave the field NULL
751              * and catch the error during the sanity checks later
752              */
753             newroot->hostname = xstrdup (cvsroot_copy);
754
755         /* restore the '/' */
756         cvsroot_copy = firstslash;
757         *cvsroot_copy = '/';
758     }
759 #endif /* defined(CLIENT_SUPPORT) || defined (SERVER_SUPPORT) */
760
761     /*
762      * Parse the path for all methods.
763      */
764     /* Here & local_cvsroot() should be the only places this needs to be
765      * called on a CVSROOT now.  cvsroot->original is saved for error messages
766      * and, otherwise, we want no trailing slashes.
767      */
768     Sanitize_Repository_Name (cvsroot_copy);
769     newroot->directory = xstrdup (cvsroot_copy);
770
771     /*
772      * Do various sanity checks.
773      */
774
775 #if defined(CLIENT_SUPPORT) || defined (SERVER_SUPPORT)
776     if (newroot->username && ! newroot->hostname)
777     {
778         error (0, 0, "Missing hostname in CVSROOT.");
779         goto error_exit;
780     }
781
782     /* We won't have attempted to parse these without CLIENT_SUPPORT or
783      * SERVER_SUPPORT.
784      */
785     check_hostname = 0;
786     no_password = 1;
787     no_proxy = 1;
788     no_port = 0;
789 #endif /* defined (CLIENT_SUPPORT) || defined (SERVER_SUPPORT) */
790     switch (newroot->method)
791     {
792     case local_method:
793 #if defined(CLIENT_SUPPORT) || defined (SERVER_SUPPORT)
794         if (newroot->username || newroot->hostname)
795         {
796             error (0, 0, "Can't specify hostname and username in CVSROOT");
797             error (0, 0, "when using local access method.");
798             goto error_exit;
799         }
800 #endif /* defined(CLIENT_SUPPORT) || defined (SERVER_SUPPORT) */
801         /* cvs.texinfo has always told people that CVSROOT must be an
802            absolute pathname.  Furthermore, attempts to use a relative
803            pathname produced various errors (I couldn't get it to work),
804            so there would seem to be little risk in making this a fatal
805            error.  */
806         if (!ISABSOLUTE (newroot->directory))
807         {
808             error (0, 0, "CVSROOT must be an absolute pathname (not `%s')",
809                    newroot->directory);
810             error (0, 0, "when using local access method.");
811             goto error_exit;
812         }
813 #if defined(CLIENT_SUPPORT) || defined (SERVER_SUPPORT)
814         /* We don't need to check for these in :local: mode, really, since
815          * we shouldn't be able to hit the code above which parses them, but
816          * I'm leaving them here in lieu of assertions.
817          */
818         no_port = 1;
819         /* no_password already set */
820 #endif /* defined(CLIENT_SUPPORT) || defined (SERVER_SUPPORT) */
821         break;
822 #if defined(CLIENT_SUPPORT) || defined (SERVER_SUPPORT)
823     case fork_method:
824         /* We want :fork: to behave the same as other remote access
825            methods.  Therefore, don't check to see that the repository
826            name is absolute -- let the server do it.  */
827         if (newroot->username || newroot->hostname)
828         {
829             error (0, 0, "Can't specify hostname and username in CVSROOT");
830             error (0, 0, "when using fork access method.");
831             goto error_exit;
832         }
833         newroot->hostname = xstrdup("server");  /* for error messages */
834         if (!ISABSOLUTE (newroot->directory))
835         {
836             error (0, 0, "CVSROOT must be an absolute pathname (not `%s')",
837                    newroot->directory);
838             error (0, 0, "when using fork access method.");
839             goto error_exit;
840         }
841         no_port = 1;
842         /* no_password already set */
843         break;
844     case kserver_method:
845         check_hostname = 1;
846         /* no_password already set */
847         break;
848     case gserver_method:
849         check_hostname = 1;
850         no_proxy = 0;
851         /* no_password already set */
852         break;
853     case server_method:
854     case ext_method:
855         no_port = 1;
856     case extssh_method:
857         /* no_password already set */
858         check_hostname = 1;
859         break;
860     case pserver_method:
861         no_password = 0;
862         no_proxy = 0;
863         check_hostname = 1;
864         break;
865 #endif /* defined(CLIENT_SUPPORT) || defined (SERVER_SUPPORT) */
866     default:
867         error (1, 0, "Invalid method found in parse_cvsroot");
868     }
869
870 #if defined(CLIENT_SUPPORT) || defined (SERVER_SUPPORT)
871     if (no_password && newroot->password)
872     {
873         error (0, 0, "CVSROOT password specification is only valid for");
874         error (0, 0, "pserver connection method.");
875         goto error_exit;
876     }
877     if (no_proxy && (newroot->proxy_hostname || newroot->proxy_port))
878     {
879         error (0, 0,
880 "CVSROOT proxy specification is only valid for gserver and");
881         error (0, 0, "pserver connection methods.");
882         goto error_exit;
883     }
884
885     if (!newroot->proxy_hostname && newroot->proxy_port)
886     {
887         error (0, 0, "Proxy port specified in CVSROOT without proxy host.");
888         goto error_exit;
889     }
890
891     if (check_hostname && !newroot->hostname)
892     {
893         error (0, 0, "Didn't specify hostname in CVSROOT.");
894         goto error_exit;
895     }
896
897     if (no_port && newroot->port)
898     {
899         error (0, 0,
900 "CVSROOT port specification is only valid for extssh,");
901         error (0, 0, "gserver, kserver and pserver connection methods.");
902         goto error_exit;
903     }
904 #endif /* defined(CLIENT_SUPPORT) || defined (SERVER_SUPPORT) */
905
906     if (*newroot->directory == '\0')
907     {
908         error (0, 0, "Missing directory in CVSROOT.");
909         goto error_exit;
910     }
911     
912     /* Hooray!  We finally parsed it! */
913     free (cvsroot_save);
914
915     if (!cache) cache = getlist();
916     node = getnode();
917     node->key = xstrdup (newroot->original);
918     node->data = newroot;
919     addnode (cache, node);
920     return newroot;
921
922 error_exit:
923     free (cvsroot_save);
924     free_cvsroot_t (newroot);
925     return NULL;
926 }
927
928
929
930 #ifdef AUTH_CLIENT_SUPPORT
931 /* Use root->username, root->hostname, root->port, and root->directory
932  * to create a normalized CVSROOT fit for the .cvspass file
933  *
934  * username defaults to the result of getcaller()
935  * port defaults to the result of get_cvs_port_number()
936  *
937  * FIXME - we could cache the canonicalized version of a root inside the
938  * cvsroot_t, but we'd have to un'const the input here and stop expecting the
939  * caller to be responsible for our return value
940  *
941  * ASSUMPTIONS
942  *   ROOT->method == pserver_method
943  */
944 char *
945 normalize_cvsroot (const cvsroot_t *root)
946 {
947     char *cvsroot_canonical;
948     char *p, *hostname;
949
950     assert (root && root->hostname && root->directory);
951
952     /* use a lower case hostname since we know hostnames are case insensitive */
953     /* Some logic says we should be tacking our domain name on too if it isn't
954      * there already, but for now this works.  Reverse->Forward lookups are
955      * almost certainly too much since that would make CVS immune to some of
956      * the DNS trickery that makes life easier for sysadmins when they want to
957      * move a repository or the like
958      */
959     p = hostname = xstrdup (root->hostname);
960     while (*p)
961     {
962         *p = tolower (*p);
963         p++;
964     }
965
966     cvsroot_canonical = Xasprintf (":pserver:%s@%s:%d%s",
967                                    root->username ? root->username
968                                                   : getcaller(),
969                                    hostname, get_cvs_port_number (root),
970                                    root->directory);
971
972     free (hostname);
973     return cvsroot_canonical;
974 }
975 #endif /* AUTH_CLIENT_SUPPORT */
976
977
978
979 #ifdef PROXY_SUPPORT
980 /* A walklist() function to walk the root_allow list looking for a PrimaryServer
981  * configuration with a directory matching the requested directory.
982  *
983  * If found, replace it.
984  */
985 static bool get_local_root_dir_done;
986 static int
987 get_local_root_dir (Node *p, void *root_in)
988 {
989     struct config *c = p->data;
990     char **r = root_in;
991
992     if (get_local_root_dir_done)
993         return 0;
994
995     if (c->PrimaryServer && !strcmp (*r, c->PrimaryServer->directory))
996     {
997         free (*r);
998         *r = xstrdup (p->key);
999         get_local_root_dir_done = true;
1000     }
1001     return 0;
1002 }
1003 #endif /* PROXY_SUPPORT */
1004
1005
1006
1007 /* allocate and return a cvsroot_t structure set up as if we're using the local
1008  * repository DIR.  */
1009 cvsroot_t *
1010 local_cvsroot (const char *dir)
1011 {
1012     cvsroot_t *newroot = new_cvsroot_t();
1013
1014     newroot->original = xstrdup(dir);
1015     newroot->method = local_method;
1016     newroot->directory = xstrdup(dir);
1017     /* Here and parse_cvsroot() should be the only places this needs to be
1018      * called on a CVSROOT now.  cvsroot->original is saved for error messages
1019      * and, otherwise, we want no trailing slashes.
1020      */
1021     Sanitize_Repository_Name (newroot->directory);
1022
1023 #ifdef PROXY_SUPPORT
1024     /* Translate the directory to a local one in the case that we are
1025      * configured as a secondary.  If root_allow has not been initialized,
1026      * nothing happens.
1027      */
1028     get_local_root_dir_done = false;
1029     walklist (root_allow, get_local_root_dir, &newroot->directory);
1030 #endif /* PROXY_SUPPORT */
1031
1032     return newroot;
1033 }
1034
1035
1036
1037 #ifdef DEBUG
1038 /* This is for testing the parsing function.  Use
1039
1040      gcc -I. -I.. -I../lib -DDEBUG root.c -o root
1041
1042    to compile.  */
1043
1044 #include <stdio.h>
1045
1046 char *program_name = "testing";
1047 char *cvs_cmd_name = "parse_cvsroot";           /* XXX is this used??? */
1048
1049 void
1050 main (int argc, char *argv[])
1051 {
1052     program_name = argv[0];
1053
1054     if (argc != 2)
1055     {
1056         fprintf (stderr, "Usage: %s <CVSROOT>\n", program_name);
1057         exit (2);
1058     }
1059   
1060     if ((current_parsed_root = parse_cvsroot (argv[1])) == NULL)
1061     {
1062         fprintf (stderr, "%s: Parsing failed.\n", program_name);
1063         exit (1);
1064     }
1065     printf ("CVSroot: %s\n", argv[1]);
1066     printf ("current_parsed_root->method: %s\n",
1067             method_names[current_parsed_root->method]);
1068     printf ("current_parsed_root->username: %s\n",
1069             current_parsed_root->username
1070               ? current_parsed_root->username : "NULL");
1071     printf ("current_parsed_root->hostname: %s\n",
1072             current_parsed_root->hostname
1073               ? current_parsed_root->hostname : "NULL");
1074     printf ("current_parsed_root->directory: %s\n",
1075             current_parsed_root->directory);
1076
1077    exit (0);
1078    /* NOTREACHED */
1079 }
1080 #endif