contrib/cvs/src/root.c

   1 /*
   2  * Copyright (C) 1986-2008 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", "extssh", "fork"
  27 };
  28
  29 #ifndef DEBUG
  30
  31 cvsroot_t *
  32 Name_Root (dir, update_dir)
  33     const char *dir;
  34     const char *update_dir;
  35 {
  36     FILE *fpin;
  37     cvsroot_t *ret;
  38     const char *xupdate_dir;
  39     char *root = NULL;
  40     size_t root_allocated = 0;
  41     char *tmp;
  42     char *cvsadm;
  43     char *cp;
  44     int len;
  45
  46     if (update_dir && *update_dir)
  47         xupdate_dir = update_dir;
  48     else
  49         xupdate_dir = ".";
  50
  51     if (dir != NULL)
  52     {
  53         cvsadm = xmalloc (strlen (dir) + sizeof (CVSADM) + 10);
  54         (void) sprintf (cvsadm, "%s/%s", dir, CVSADM);
  55         tmp = xmalloc (strlen (dir) + sizeof (CVSADM_ROOT) + 10);
  56         (void) sprintf (tmp, "%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 = open_file (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         free_cvsroot_t (ret);
 122         ret = NULL;
 123         goto out;
 124     }
 125
 126
 127  out:
 128     free (cvsadm);
 129     free (tmp);
 130     if (root != NULL)
 131         free (root);
 132     return ret;
 133 }
 134
 135
 136
 137 /*
 138  * Write the CVS/Root file so that the environment variable CVSROOT
 139  * and/or the -d option to cvs will be validated or not necessary for
 140  * future work.
 141  */
 142 void
 143 Create_Root (dir, rootdir)
 144     const char *dir;
 145     const char *rootdir;
 146 {
 147     FILE *fout;
 148     char *tmp;
 149
 150     if (noexec)
 151         return;
 152
 153     /* record the current cvs root */
 154
 155     if (rootdir != NULL)
 156     {
 157         if (dir != NULL)
 158         {
 159             tmp = xmalloc (strlen (dir) + sizeof (CVSADM_ROOT) + 10);
 160             (void) sprintf (tmp, "%s/%s", dir, CVSADM_ROOT);
 161         }
 162         else
 163             tmp = xstrdup (CVSADM_ROOT);
 164
 165         fout = open_file (tmp, "w+");
 166         if (fprintf (fout, "%s\n", rootdir) < 0)
 167             error (1, errno, "write to %s failed", tmp);
 168         if (fclose (fout) == EOF)
 169             error (1, errno, "cannot close %s", tmp);
 170         free (tmp);
 171     }
 172 }
 173
 174 #endif /* ! DEBUG */
 175
 176
 177 /* The root_allow_* stuff maintains a list of legal CVSROOT
 178    directories.  Then we can check against them when a remote user
 179    hands us a CVSROOT directory.  */
 180
 181 static int root_allow_count;
 182 static char **root_allow_vector;
 183 static int root_allow_size;
 184
 185 int
 186 root_allow_used ()
 187 {
 188     return root_allow_count;
 189 }
 190
 191 void
 192 root_allow_add (arg)
 193     char *arg;
 194 {
 195     char *p;
 196
 197     if (root_allow_size <= root_allow_count)
 198     {
 199         if (root_allow_size == 0)
 200         {
 201             root_allow_size = 1;
 202             root_allow_vector =
 203                 (char **) xmalloc (root_allow_size * sizeof (char *));
 204         }
 205         else
 206         {
 207             root_allow_size *= 2;
 208             root_allow_vector =
 209                 (char **) xrealloc (root_allow_vector,
 210                                    root_allow_size * sizeof (char *));
 211         }
 212
 213         if (root_allow_vector == NULL)
 214         {
 215         no_memory:
 216             /* Strictly speaking, we're not supposed to output anything
 217                now.  But we're about to exit(), give it a try.  */
 218             printf ("E Fatal server error, aborting.\n\
 219 error ENOMEM Virtual memory exhausted.\n");
 220
 221             error_exit ();
 222         }
 223     }
 224     p = xmalloc (strlen (arg) + 1);
 225     if (p == NULL)
 226         goto no_memory;
 227     strcpy (p, arg);
 228     root_allow_vector[root_allow_count++] = p;
 229 }
 230
 231 void
 232 root_allow_free ()
 233 {
 234     if (root_allow_vector != NULL)
 235         free_names (&root_allow_count, root_allow_vector);
 236     root_allow_size = 0;
 237 }
 238
 239 int
 240 root_allow_ok (arg)
 241     char *arg;
 242 {
 243     int i;
 244
 245     if (root_allow_count == 0)
 246     {
 247         /* Probably someone upgraded from CVS before 1.9.10 to 1.9.10
 248            or later without reading the documentation about
 249            --allow-root.  Printing an error here doesn't disclose any
 250            particularly useful information to an attacker because a
 251            CVS server configured in this way won't let *anyone* in.  */
 252
 253         /* Note that we are called from a context where we can spit
 254            back "error" rather than waiting for the next request which
 255            expects responses.  */
 256         printf ("\
 257 error 0 Server configuration missing --allow-root in inetd.conf\n");
 258         error_exit ();
 259     }
 260
 261     for (i = 0; i < root_allow_count; ++i)
 262         if (strcmp (root_allow_vector[i], arg) == 0)
 263             return 1;
 264     return 0;
 265 }
 266
 267
 268
 269 /* This global variable holds the global -d option.  It is NULL if -d
 270    was not used, which means that we must get the CVSroot information
 271    from the CVSROOT environment variable or from a CVS/Root file.  */
 272 char *CVSroot_cmdline;
 273
 274
 275
 276 /* FIXME - Deglobalize this. */
 277 cvsroot_t *current_parsed_root = NULL;
 278
 279
 280
 281 /* allocate and initialize a cvsroot_t
 282  *
 283  * We must initialize the strings to NULL so we know later what we should
 284  * free
 285  *
 286  * Some of the other zeroes remain meaningful as, "never set, use default",
 287  * or the like
 288  */
 289 static cvsroot_t *
 290 new_cvsroot_t ()
 291 {
 292     cvsroot_t *newroot;
 293
 294     /* gotta store it somewhere */
 295     newroot = xmalloc(sizeof(cvsroot_t));
 296
 297     newroot->original = NULL;
 298     newroot->method = null_method;
 299     newroot->isremote = 0;
 300 #ifdef CLIENT_SUPPORT
 301     newroot->username = NULL;
 302     newroot->password = NULL;
 303     newroot->hostname = NULL;
 304     newroot->port = 0;
 305     newroot->directory = NULL;
 306     newroot->proxy_hostname = NULL;
 307     newroot->proxy_port = 0;
 308 #endif /* CLIENT_SUPPORT */
 309
 310     return newroot;
 311 }
 312
 313
 314
 315 /* Dispose of a cvsroot_t and its component parts */
 316 void
 317 free_cvsroot_t (root)
 318     cvsroot_t *root;
 319 {
 320     if (root->original != NULL)
 321         free (root->original);
 322     if (root->directory != NULL)
 323         free (root->directory);
 324 #ifdef CLIENT_SUPPORT
 325     if (root->username != NULL)
 326         free (root->username);
 327     if (root->password != NULL)
 328     {
 329         /* I like to be paranoid */
 330         memset (root->password, 0, strlen (root->password));
 331         free (root->password);
 332     }
 333     if (root->hostname != NULL)
 334         free (root->hostname);
 335     if (root->proxy_hostname != NULL)
 336         free (root->proxy_hostname);
 337 #endif /* CLIENT_SUPPORT */
 338     free (root);
 339 }
 340
 341
 342
 343 /*
 344  * Parse a CVSROOT string to allocate and return a new cvsroot_t structure.
 345  * Valid specifications are:
 346  *
 347  *      :(gserver|kserver|pserver):[[user][:password]@]host[:[port]]/path
 348  *      [:(ext|server):][[user]@]host[:]/path
 349  *      [:local:[e:]]/path
 350  *      :fork:/path
 351  *
 352  * INPUTS
 353  *      root_in         C String containing the CVSROOT to be parsed.
 354  *
 355  * RETURNS
 356  *      A pointer to a newly allocated cvsroot_t structure upon success and
 357  *      NULL upon failure.  The caller is responsible for disposing of
 358  *      new structures with a call to free_cvsroot_t().
 359  *
 360  * NOTES
 361  *      This would have been a lot easier to write in Perl.
 362  *
 363  * SEE ALSO
 364  *      free_cvsroot_t()
 365  */
 366 cvsroot_t *
 367 parse_cvsroot (root_in)
 368     const char *root_in;
 369 {
 370     cvsroot_t *newroot;                 /* the new root to be returned */
 371     char *cvsroot_save;                 /* what we allocated so we can dispose
 372                                          * it when finished */
 373     char *firstslash;                   /* save where the path spec starts
 374                                          * while we parse
 375                                          * [[user][:password]@]host[:[port]]
 376                                          */
 377     char *cvsroot_copy, *p, *q;         /* temporary pointers for parsing */
 378 #ifdef CLIENT_SUPPORT
 379     int check_hostname, no_port, no_password;
 380 #endif /* CLIENT_SUPPORT */
 381
 382     assert (root_in);
 383
 384     /* allocate some space */
 385     newroot = new_cvsroot_t();
 386
 387     /* save the original string */
 388     newroot->original = xstrdup (root_in);
 389
 390     /* and another copy we can munge while parsing */
 391     cvsroot_save = cvsroot_copy = xstrdup (root_in);
 392
 393     if (*cvsroot_copy == ':')
 394     {
 395         char *method = ++cvsroot_copy;
 396
 397         /* Access method specified, as in
 398          * "cvs -d :(gserver|kserver|pserver):[[user][:password]@]host[:[port]]/path",
 399          * "cvs -d [:(ext|server):][[user]@]host[:]/path",
 400          * "cvs -d :local:e:\path",
 401          * "cvs -d :fork:/path".
 402          * We need to get past that part of CVSroot before parsing the
 403          * rest of it.
 404          */
 405
 406         if (! (p = strchr (method, ':')))
 407         {
 408             error (0, 0, "No closing `:' on method in CVSROOT.");
 409             goto error_exit;
 410         }
 411         *p = '\0';
 412         cvsroot_copy = ++p;
 413
 414 #ifdef CLIENT_SUPPORT
 415         /* Look for method options, for instance, proxy, proxyport.
 416          * We don't handle these, but we like to try and warn the user that
 417          * they are being ignored.
 418          */
 419         if ((p = strchr (method, ';')) != NULL)
 420         {
 421             *p++ = '\0';
 422             if (!really_quiet)
 423             {
 424                 error (0, 0,
 425 "WARNING: Ignoring method options found in CVSROOT: `%s'.",
 426                        p);
 427                 error (0, 0,
 428 "Use CVS version 1.12.7 or later to handle method options.");
 429             }
 430         }
 431 #endif /* CLIENT_SUPPORT */
 432
 433         /* Now we have an access method -- see if it's valid. */
 434
 435         if (strcmp (method, "local") == 0)
 436             newroot->method = local_method;
 437         else if (strcmp (method, "pserver") == 0)
 438             newroot->method = pserver_method;
 439         else if (strcmp (method, "kserver") == 0)
 440             newroot->method = kserver_method;
 441         else if (strcmp (method, "gserver") == 0)
 442             newroot->method = gserver_method;
 443         else if (strcmp (method, "server") == 0)
 444             newroot->method = server_method;
 445         else if (strcmp (method, "ext") == 0)
 446             newroot->method = ext_method;
 447         else if (strcmp (method, "extssh") == 0)
 448             newroot->method = extssh_method;
 449         else if (strcmp (method, "fork") == 0)
 450             newroot->method = fork_method;
 451         else
 452         {
 453             error (0, 0, "Unknown method (`%s') in CVSROOT.", method);
 454             goto error_exit;
 455         }
 456     }
 457     else
 458     {
 459         /* If the method isn't specified, assume EXT_METHOD if the string looks
 460            like a relative path and LOCAL_METHOD otherwise.  */
 461
 462         newroot->method = ((*cvsroot_copy != '/' && strchr (cvsroot_copy, '/'))
 463                           ? ext_method
 464                           : local_method);
 465     }
 466
 467     newroot->isremote = (newroot->method != local_method);
 468
 469     if ((newroot->method != local_method)
 470         && (newroot->method != fork_method))
 471     {
 472         /* split the string into [[user][:password]@]host[:[port]] & /path
 473          *
 474          * this will allow some characters such as '@' & ':' to remain unquoted
 475          * in the path portion of the spec
 476          */
 477         if ((p = strchr (cvsroot_copy, '/')) == NULL)
 478         {
 479             error (0, 0, "CVSROOT requires a path spec:");
 480             error (0, 0,
 481 ":(gserver|kserver|pserver):[[user][:password]@]host[:[port]]/path");
 482             error (0, 0, "[:(ext|server):][[user]@]host[:]/path");
 483             goto error_exit;
 484         }
 485         firstslash = p;         /* == NULL if '/' not in string */
 486         *p = '\0';
 487
 488         /* Don't parse username, password, hostname, or port without client
 489          * support.
 490          */
 491 #ifdef CLIENT_SUPPORT
 492         /* Check to see if there is a username[:password] in the string. */
 493         if ((p = strchr (cvsroot_copy, '@')) != NULL)
 494         {
 495             *p = '\0';
 496             /* check for a password */
 497             if ((q = strchr (cvsroot_copy, ':')) != NULL)
 498             {
 499                 *q = '\0';
 500                 newroot->password = xstrdup (++q);
 501                 /* Don't check for *newroot->password == '\0' since
 502                  * a user could conceivably wish to specify a blank password
 503                  *
 504                  * (newroot->password == NULL means to use the
 505                  * password from .cvspass)
 506                  */
 507             }
 508
 509             /* copy the username */
 510             if (*cvsroot_copy != '\0')
 511                 /* a blank username is impossible, so leave it NULL in that
 512                  * case so we know to use the default username
 513                  */
 514                 newroot->username = xstrdup (cvsroot_copy);
 515
 516             cvsroot_copy = ++p;
 517         }
 518
 519         /* now deal with host[:[port]] */
 520
 521         /* the port */
 522         if ((p = strchr (cvsroot_copy, ':')) != NULL)
 523         {
 524             *p++ = '\0';
 525             if (strlen(p))
 526             {
 527                 q = p;
 528                 if (*q == '-') q++;
 529                 while (*q)
 530                 {
 531                     if (!isdigit(*q++))
 532                     {
 533                         error (0, 0,
 534 "CVSROOT may only specify a positive, non-zero, integer port (not `%s').",
 535                                 p);
 536                         error (0, 0,
 537                                "Perhaps you entered a relative pathname?");
 538                         goto error_exit;
 539                     }
 540                 }
 541                 if ((newroot->port = atoi (p)) <= 0)
 542                 {
 543                     error (0, 0,
 544 "CVSROOT may only specify a positive, non-zero, integer port (not `%s').",
 545                             p);
 546                     error (0, 0, "Perhaps you entered a relative pathname?");
 547                     goto error_exit;
 548                 }
 549             }
 550         }
 551
 552         /* copy host */
 553         if (*cvsroot_copy != '\0')
 554             /* blank hostnames are invalid, but for now leave the field NULL
 555              * and catch the error during the sanity checks later
 556              */
 557             newroot->hostname = xstrdup (cvsroot_copy);
 558
 559         /* restore the '/' */
 560         cvsroot_copy = firstslash;
 561         *cvsroot_copy = '/';
 562 #endif /* CLIENT_SUPPORT */
 563     }
 564
 565     /*
 566      * Parse the path for all methods.
 567      */
 568     /* Here & local_cvsroot() should be the only places this needs to be
 569      * called on a CVSROOT now.  cvsroot->original is saved for error messages
 570      * and, otherwise, we want no trailing slashes.
 571      */
 572     Sanitize_Repository_Name( cvsroot_copy );
 573     newroot->directory = xstrdup(cvsroot_copy);
 574
 575     /*
 576      * Do various sanity checks.
 577      */
 578
 579 #if ! defined (CLIENT_SUPPORT) && ! defined (DEBUG)
 580     if (newroot->method != local_method)
 581     {
 582         error (0, 0, "CVSROOT is set for a remote access method but your");
 583         error (0, 0, "CVS executable doesn't support it.");
 584         goto error_exit;
 585     }
 586 #endif
 587
 588 #if ! defined (SERVER_SUPPORT) && ! defined (DEBUG)
 589     if (newroot->method == fork_method)
 590     {
 591         error (0, 0, "CVSROOT is set to use the :fork: access method but your");
 592         error (0, 0, "CVS executable doesn't support it.");
 593         goto error_exit;
 594      }
 595 #endif
 596
 597 #ifdef CLIENT_SUPPORT
 598     if (newroot->username && ! newroot->hostname)
 599     {
 600         error (0, 0, "Missing hostname in CVSROOT.");
 601         goto error_exit;
 602     }
 603
 604     check_hostname = 0;
 605     no_password = 1;
 606     no_port = 0;
 607 #endif /* CLIENT_SUPPORT */
 608     switch (newroot->method)
 609     {
 610     case local_method:
 611 #ifdef CLIENT_SUPPORT
 612         if (newroot->username || newroot->hostname)
 613         {
 614             error (0, 0, "Can't specify hostname and username in CVSROOT");
 615             error (0, 0, "when using local access method.");
 616             goto error_exit;
 617         }
 618         no_port = 1;
 619         /* no_password already set */
 620 #endif /* CLIENT_SUPPORT */
 621         /* cvs.texinfo has always told people that CVSROOT must be an
 622            absolute pathname.  Furthermore, attempts to use a relative
 623            pathname produced various errors (I couldn't get it to work),
 624            so there would seem to be little risk in making this a fatal
 625            error.  */
 626         if (!isabsolute (newroot->directory))
 627         {
 628             error (0, 0, "CVSROOT must be an absolute pathname (not `%s')",
 629                    newroot->directory);
 630             error (0, 0, "when using local access method.");
 631             goto error_exit;
 632         }
 633         break;
 634 #ifdef CLIENT_SUPPORT
 635     case fork_method:
 636         /* We want :fork: to behave the same as other remote access
 637            methods.  Therefore, don't check to see that the repository
 638            name is absolute -- let the server do it.  */
 639         if (newroot->username || newroot->hostname)
 640         {
 641             error (0, 0, "Can't specify hostname and username in CVSROOT");
 642             error (0, 0, "when using fork access method.");
 643             goto error_exit;
 644         }
 645         newroot->hostname = xstrdup("server");  /* for error messages */
 646         if (!isabsolute (newroot->directory))
 647         {
 648             error (0, 0, "CVSROOT must be an absolute pathname (not `%s')",
 649                    newroot->directory);
 650             error (0, 0, "when using fork access method.");
 651             goto error_exit;
 652         }
 653         no_port = 1;
 654         /* no_password already set */
 655         break;
 656     case kserver_method:
 657 # ifndef HAVE_KERBEROS
 658         error (0, 0, "CVSROOT is set for a kerberos access method but your");
 659         error (0, 0, "CVS executable doesn't support it.");
 660         goto error_exit;
 661 # else
 662         check_hostname = 1;
 663         /* no_password already set */
 664         break;
 665 # endif
 666     case gserver_method:
 667 # ifndef HAVE_GSSAPI
 668         error (0, 0, "CVSROOT is set for a GSSAPI access method but your");
 669         error (0, 0, "CVS executable doesn't support it.");
 670         goto error_exit;
 671 # else
 672         check_hostname = 1;
 673         /* no_password already set */
 674         break;
 675 # endif
 676     case server_method:
 677     case ext_method:
 678     case extssh_method:
 679         no_port = 1;
 680         /* no_password already set */
 681         check_hostname = 1;
 682         break;
 683     case pserver_method:
 684         no_password = 0;
 685         check_hostname = 1;
 686         break;
 687 #endif /* CLIENT_SUPPORT */
 688     default:
 689         error (1, 0, "Invalid method found in parse_cvsroot");
 690     }
 691
 692 #ifdef CLIENT_SUPPORT
 693     if (no_password && newroot->password)
 694     {
 695         error (0, 0, "CVSROOT password specification is only valid for");
 696         error (0, 0, "pserver connection method.");
 697         goto error_exit;
 698     }
 699
 700     if (check_hostname && !newroot->hostname)
 701     {
 702         error (0, 0, "Didn't specify hostname in CVSROOT.");
 703         goto error_exit;
 704     }
 705
 706     if (no_port && newroot->port)
 707         {
 708             error (0, 0, "CVSROOT port specification is only valid for gserver, kserver,");
 709             error (0, 0, "and pserver connection methods.");
 710             goto error_exit;
 711         }
 712 #endif /* CLIENT_SUPPORT */
 713
 714     if (*newroot->directory == '\0')
 715     {
 716         error (0, 0, "Missing directory in CVSROOT.");
 717         goto error_exit;
 718     }
 719
 720     /* Hooray!  We finally parsed it! */
 721     free (cvsroot_save);
 722     return newroot;
 723
 724 error_exit:
 725     free (cvsroot_save);
 726     free_cvsroot_t (newroot);
 727     return NULL;
 728 }
 729
 730
 731
 732 #ifdef AUTH_CLIENT_SUPPORT
 733 /* Use root->username, root->hostname, root->port, and root->directory
 734  * to create a normalized CVSROOT fit for the .cvspass file
 735  *
 736  * username defaults to the result of getcaller()
 737  * port defaults to the result of get_cvs_port_number()
 738  *
 739  * FIXME - we could cache the canonicalized version of a root inside the
 740  * cvsroot_t, but we'd have to un'const the input here and stop expecting the
 741  * caller to be responsible for our return value
 742  */
 743 char *
 744 normalize_cvsroot (root)
 745     const cvsroot_t *root;
 746 {
 747     char *cvsroot_canonical;
 748     char *p, *hostname, *username;
 749     char port_s[64];
 750
 751     assert (root && root->hostname && root->directory);
 752
 753     /* get the appropriate port string */
 754     sprintf (port_s, "%d", get_cvs_port_number (root));
 755
 756     /* use a lower case hostname since we know hostnames are case insensitive */
 757     /* Some logic says we should be tacking our domain name on too if it isn't
 758      * there already, but for now this works.  Reverse->Forward lookups are
 759      * almost certainly too much since that would make CVS immune to some of
 760      * the DNS trickery that makes life easier for sysadmins when they want to
 761      * move a repository or the like
 762      */
 763     p = hostname = xstrdup(root->hostname);
 764     while (*p)
 765     {
 766         *p = tolower(*p);
 767         p++;
 768     }
 769
 770     /* get the username string */
 771     username = root->username ? root->username : getcaller();
 772     cvsroot_canonical = xmalloc ( strlen(username)
 773                                 + strlen(hostname) + strlen(port_s)
 774                                 + strlen(root->directory) + 12);
 775     sprintf (cvsroot_canonical, ":pserver:%s@%s:%s%s",
 776             username, hostname, port_s, root->directory);
 777
 778     free (hostname);
 779     return cvsroot_canonical;
 780 }
 781 #endif /* AUTH_CLIENT_SUPPORT */
 782
 783
 784
 785 /* allocate and return a cvsroot_t structure set up as if we're using the local
 786  * repository DIR.  */
 787 cvsroot_t *
 788 local_cvsroot (dir)
 789     const char *dir;
 790 {
 791     cvsroot_t *newroot = new_cvsroot_t();
 792
 793     newroot->original = xstrdup(dir);
 794     newroot->method = local_method;
 795     newroot->directory = xstrdup(dir);
 796     /* Here and parse_cvsroot() should be the only places this needs to be
 797      * called on a CVSROOT now.  cvsroot->original is saved for error messages
 798      * and, otherwise, we want no trailing slashes.
 799      */
 800     Sanitize_Repository_Name( newroot->directory );
 801     return newroot;
 802 }
 803
 804
 805
 806 #ifdef DEBUG
 807 /* This is for testing the parsing function.  Use
 808
 809      gcc -I. -I.. -I../lib -DDEBUG root.c -o root
 810
 811    to compile.  */
 812
 813 #include <stdio.h>
 814
 815 char *program_name = "testing";
 816 char *cvs_cmd_name = "parse_cvsroot";           /* XXX is this used??? */
 817
 818 /* Toy versions of various functions when debugging under unix.  Yes,
 819    these make various bad assumptions, but they're pretty easy to
 820    debug when something goes wrong.  */
 821
 822 void
 823 error_exit PROTO ((void))
 824 {
 825     exit (1);
 826 }
 827
 828 int
 829 isabsolute (dir)
 830     const char *dir;
 831 {
 832     return (dir && (*dir == '/'));
 833 }
 834
 835 void
 836 main (argc, argv)
 837     int argc;
 838     char *argv[];
 839 {
 840     program_name = argv[0];
 841
 842     if (argc != 2)
 843     {
 844         fprintf (stderr, "Usage: %s <CVSROOT>\n", program_name);
 845         exit (2);
 846     }
 847
 848     if ((current_parsed_root = parse_cvsroot (argv[1])) == NULL)
 849     {
 850         fprintf (stderr, "%s: Parsing failed.\n", program_name);
 851         exit (1);
 852     }
 853     printf ("CVSroot: %s\n", argv[1]);
 854     printf ("current_parsed_root->method: %s\n", method_names[current_parsed_root->method]);
 855     printf ("current_parsed_root->username: %s\n",
 856             current_parsed_root->username ? current_parsed_root->username : "NULL");
 857     printf ("current_parsed_root->hostname: %s\n",
 858             current_parsed_root->hostname ? current_parsed_root->hostname : "NULL");
 859     printf ("current_parsed_root->directory: %s\n", current_parsed_root->directory);
 860
 861    exit (0);
 862    /* NOTREACHED */
 863 }
 864 #endif