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