granicus.if.org Git - postgresql/blob - src/interfaces/libpq/fe-auth.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * fe-auth.c
   4  *         The front-end (client) authorization routines
   5  *
   6  * Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
   7  * Portions Copyright (c) 1994, Regents of the University of California
   8  *
   9  * NOTE: the error message strings returned by this module must not
  10  * exceed INITIAL_EXPBUFFER_SIZE (currently 256 bytes).
  11  *
  12  * IDENTIFICATION
  13  *        $PostgreSQL: pgsql/src/interfaces/libpq/fe-auth.c,v 1.99 2005/01/12 21:37:54 tgl Exp $
  14  *
  15  *-------------------------------------------------------------------------
  16  */
  17
  18 /*
  19  * INTERFACE ROUTINES
  20  *         frontend (client) routines:
  21  *              fe_sendauth                             send authentication information
  22  *              fe_getauthname                  get user's name according to the client side
  23  *                                                              of the authentication system
  24  *              fe_setauthsvc                   set frontend authentication service
  25  *              fe_getauthsvc                   get current frontend authentication service
  26  *
  27  *
  28  *
  29  */
  30
  31 #include "postgres_fe.h"
  32
  33 #ifdef WIN32
  34 #include "win32.h"
  35 #else
  36 #include <unistd.h>
  37 #include <fcntl.h>
  38 #include <errno.h>
  39 #include <sys/types.h>
  40 #include <sys/param.h>                  /* for MAXHOSTNAMELEN on most */
  41 #include <sys/socket.h>
  42 #if defined(HAVE_STRUCT_CMSGCRED) || defined(HAVE_STRUCT_FCRED) || defined(HAVE_STRUCT_SOCKCRED)
  43 #include <sys/uio.h>
  44 #include <sys/ucred.h>
  45 #endif
  46 #ifndef  MAXHOSTNAMELEN
  47 #include <netdb.h>                              /* for MAXHOSTNAMELEN on some */
  48 #endif
  49 #include <pwd.h>
  50 #endif
  51
  52 #ifdef HAVE_CRYPT_H
  53 #include <crypt.h>
  54 #endif
  55
  56 #include "libpq-fe.h"
  57 #include "libpq-int.h"
  58 #include "fe-auth.h"
  59 #include "libpq/crypt.h"
  60
  61
  62 /*
  63  * common definitions for generic fe/be routines
  64  */
  65
  66 #define STARTUP_MSG             7               /* Initialise a connection */
  67 #define STARTUP_KRB4_MSG        10      /* krb4 session follows */
  68 #define STARTUP_KRB5_MSG        11      /* krb5 session follows */
  69 #define STARTUP_PASSWORD_MSG    14              /* Password follows */
  70
  71 struct authsvc
  72 {
  73         const char *name;                       /* service nickname (for command line) */
  74         MsgType         msgtype;                /* startup packet header type */
  75         int                     allowed;                /* initially allowed (before command line
  76                                                                  * option parsing)? */
  77 };
  78
  79 /*
  80  * Command-line parsing routines use this structure to map nicknames
  81  * onto service types (and the startup packets to use with them).
  82  *
  83  * Programs receiving an authentication request use this structure to
  84  * decide which authentication service types are currently permitted.
  85  * By default, all authentication systems compiled into the system are
  86  * allowed.  Unauthenticated connections are disallowed unless there
  87  * isn't any authentication system.
  88  */
  89 static const struct authsvc authsvcs[] = {
  90 #ifdef KRB4
  91         {"krb4", STARTUP_KRB4_MSG, 1},
  92         {"kerberos", STARTUP_KRB4_MSG, 1},
  93 #endif   /* KRB4 */
  94 #ifdef KRB5
  95         {"krb5", STARTUP_KRB5_MSG, 1},
  96         {"kerberos", STARTUP_KRB5_MSG, 1},
  97 #endif   /* KRB5 */
  98         {UNAUTHNAME, STARTUP_MSG,
  99 #if defined(KRB4) || defined(KRB5)
 100                 0
 101 #else                                                   /* !(KRB4 || KRB5) */
 102                 1
 103 #endif   /* !(KRB4 || KRB5) */
 104         },
 105         {"password", STARTUP_PASSWORD_MSG, 0}
 106 };
 107
 108 static const int n_authsvcs = sizeof(authsvcs) / sizeof(struct authsvc);
 109
 110 #ifdef KRB4
 111 /*
 112  * MIT Kerberos authentication system - protocol version 4
 113  */
 114
 115 #include "krb.h"
 116
 117 /* for some reason, this is not defined in krb.h ... */
 118 extern char *tkt_string(void);
 119
 120 /*
 121  * pg_krb4_init -- initialization performed before any Kerberos calls are made
 122  *
 123  * For v4, all we need to do is make sure the library routines get the right
 124  * ticket file if we want them to see a special one.  (They will open the file
 125  * themselves.)
 126  */
 127 static void
 128 pg_krb4_init()
 129 {
 130         char       *realm;
 131         static int      init_done = 0;
 132
 133         if (init_done)
 134                 return;
 135         init_done = 1;
 136
 137         /*
 138          * If the user set PGREALM, then we use a ticket file with a special
 139          * name: <usual-ticket-file-name>@<PGREALM-value>
 140          */
 141         if ((realm = getenv("PGREALM")))
 142         {
 143                 char            tktbuf[MAXPGPATH];
 144
 145                 (void) snprintf(tktbuf, sizeof(tktbuf), "%s@%s", tkt_string(), realm);
 146                 krb_set_tkt_string(tktbuf);
 147         }
 148 }
 149
 150 /*
 151  * pg_krb4_authname -- returns a pointer to static space containing whatever
 152  *                                         name the user has authenticated to the system
 153  *
 154  * We obtain this information by digging around in the ticket file.
 155  */
 156 static char *
 157 pg_krb4_authname(char *PQerrormsg)
 158 {
 159         char            instance[INST_SZ + 1];
 160         char            realm[REALM_SZ + 1];
 161         int                     status;
 162         static char name[SNAME_SZ + 1] = "";
 163
 164         if (name[0])
 165                 return name;
 166
 167         pg_krb4_init();
 168
 169         name[SNAME_SZ] = '\0';
 170         status = krb_get_tf_fullname(tkt_string(), name, instance, realm);
 171         if (status != KSUCCESS)
 172         {
 173                 snprintf(PQerrormsg, PQERRORMSG_LENGTH,
 174                                  "pg_krb4_authname: krb_get_tf_fullname: %s\n",
 175                                  krb_err_txt[status]);
 176                 return NULL;
 177         }
 178         return name;
 179 }
 180
 181 /*
 182  * pg_krb4_sendauth -- client routine to send authentication information to
 183  *                                         the server
 184  *
 185  * This routine does not do mutual authentication, nor does it return enough
 186  * information to do encrypted connections.  But then, if we want to do
 187  * encrypted connections, we'll have to redesign the whole RPC mechanism
 188  * anyway.
 189  *
 190  * If the user is too lazy to feed us a hostname, we try to come up with
 191  * something other than "localhost" since the hostname is used as an
 192  * instance and instance names in v4 databases are usually actual hostnames
 193  * (canonicalized to omit all domain suffixes).
 194  */
 195 static int
 196 pg_krb4_sendauth(char *PQerrormsg, int sock,
 197                                  struct sockaddr_in * laddr,
 198                                  struct sockaddr_in * raddr,
 199                                  const char *hostname)
 200 {
 201         long            krbopts = 0;    /* one-way authentication */
 202         KTEXT_ST        clttkt;
 203         int                     status;
 204         char            hostbuf[MAXHOSTNAMELEN];
 205         const char *realm = getenv("PGREALM");          /* NULL == current realm */
 206
 207         if (!hostname || !(*hostname))
 208         {
 209                 if (gethostname(hostbuf, MAXHOSTNAMELEN) < 0)
 210                         strcpy(hostbuf, "localhost");
 211                 hostname = hostbuf;
 212         }
 213
 214         pg_krb4_init();
 215
 216         status = krb_sendauth(krbopts,
 217                                                   sock,
 218                                                   &clttkt,
 219                                                   PG_KRB_SRVNAM,
 220                                                   hostname,
 221                                                   realm,
 222                                                   (u_long) 0,
 223                                                   NULL,
 224                                                   NULL,
 225                                                   NULL,
 226                                                   laddr,
 227                                                   raddr,
 228                                                   PG_KRB4_VERSION);
 229         if (status != KSUCCESS)
 230         {
 231                 snprintf(PQerrormsg, PQERRORMSG_LENGTH,
 232                                  libpq_gettext("Kerberos 4 error: %s\n"),
 233                                  krb_err_txt[status]);
 234                 return STATUS_ERROR;
 235         }
 236         return STATUS_OK;
 237 }
 238 #endif   /* KRB4 */
 239
 240 #ifdef KRB5
 241 /*
 242  * MIT Kerberos authentication system - protocol version 5
 243  */
 244
 245 #include <krb5.h>
 246 /* Some old versions of Kerberos do not include <com_err.h> in <krb5.h> */
 247 #if !defined(__COM_ERR_H) && !defined(__COM_ERR_H__)
 248 #include <com_err.h>
 249 #endif
 250
 251 /*
 252  * pg_an_to_ln -- return the local name corresponding to an authentication
 253  *                                name
 254  *
 255  * XXX Assumes that the first aname component is the user name.  This is NOT
 256  *         necessarily so, since an aname can actually be something out of your
 257  *         worst X.400 nightmare, like
 258  *                ORGANIZATION=U. C. Berkeley/NAME=Paul M. Aoki@CS.BERKELEY.EDU
 259  *         Note that the MIT an_to_ln code does the same thing if you don't
 260  *         provide an aname mapping database...it may be a better idea to use
 261  *         krb5_an_to_ln, except that it punts if multiple components are found,
 262  *         and we can't afford to punt.
 263  */
 264 static char *
 265 pg_an_to_ln(char *aname)
 266 {
 267         char       *p;
 268
 269         if ((p = strchr(aname, '/')) || (p = strchr(aname, '@')))
 270                 *p = '\0';
 271         return aname;
 272 }
 273
 274
 275 /*
 276  * Various krb5 state which is not connection specific, and a flag to
 277  * indicate whether we have initialised it yet.
 278  */
 279 static int      pg_krb5_initialised;
 280 static krb5_context pg_krb5_context;
 281 static krb5_ccache pg_krb5_ccache;
 282 static krb5_principal pg_krb5_client;
 283 static char *pg_krb5_name;
 284
 285
 286 static int
 287 pg_krb5_init(char *PQerrormsg)
 288 {
 289         krb5_error_code retval;
 290
 291         if (pg_krb5_initialised)
 292                 return STATUS_OK;
 293
 294         retval = krb5_init_context(&pg_krb5_context);
 295         if (retval)
 296         {
 297                 snprintf(PQerrormsg, PQERRORMSG_LENGTH,
 298                                  "pg_krb5_init: krb5_init_context: %s\n",
 299                                  error_message(retval));
 300                 return STATUS_ERROR;
 301         }
 302
 303         retval = krb5_cc_default(pg_krb5_context, &pg_krb5_ccache);
 304         if (retval)
 305         {
 306                 snprintf(PQerrormsg, PQERRORMSG_LENGTH,
 307                                  "pg_krb5_init: krb5_cc_default: %s\n",
 308                                  error_message(retval));
 309                 krb5_free_context(pg_krb5_context);
 310                 return STATUS_ERROR;
 311         }
 312
 313         retval = krb5_cc_get_principal(pg_krb5_context, pg_krb5_ccache,
 314                                                                    &pg_krb5_client);
 315         if (retval)
 316         {
 317                 snprintf(PQerrormsg, PQERRORMSG_LENGTH,
 318                                  "pg_krb5_init: krb5_cc_get_principal: %s\n",
 319                                  error_message(retval));
 320                 krb5_cc_close(pg_krb5_context, pg_krb5_ccache);
 321                 krb5_free_context(pg_krb5_context);
 322                 return STATUS_ERROR;
 323         }
 324
 325         retval = krb5_unparse_name(pg_krb5_context, pg_krb5_client, &pg_krb5_name);
 326         if (retval)
 327         {
 328                 snprintf(PQerrormsg, PQERRORMSG_LENGTH,
 329                                  "pg_krb5_init: krb5_unparse_name: %s\n",
 330                                  error_message(retval));
 331                 krb5_free_principal(pg_krb5_context, pg_krb5_client);
 332                 krb5_cc_close(pg_krb5_context, pg_krb5_ccache);
 333                 krb5_free_context(pg_krb5_context);
 334                 return STATUS_ERROR;
 335         }
 336
 337         pg_krb5_name = pg_an_to_ln(pg_krb5_name);
 338
 339         pg_krb5_initialised = 1;
 340         return STATUS_OK;
 341 }
 342
 343
 344 /*
 345  * pg_krb5_authname -- returns a pointer to static space containing whatever
 346  *                                         name the user has authenticated to the system
 347   */
 348 static const char *
 349 pg_krb5_authname(char *PQerrormsg)
 350 {
 351         if (pg_krb5_init(PQerrormsg) != STATUS_OK)
 352                 return NULL;
 353
 354         return pg_krb5_name;
 355 }
 356
 357
 358 /*
 359  * pg_krb5_sendauth -- client routine to send authentication information to
 360  *                                         the server
 361  */
 362 static int
 363 pg_krb5_sendauth(char *PQerrormsg, int sock, const char *hostname)
 364 {
 365         krb5_error_code retval;
 366         int                     ret;
 367         krb5_principal server;
 368         krb5_auth_context auth_context = NULL;
 369         krb5_error *err_ret = NULL;
 370         int                     flags;
 371
 372         ret = pg_krb5_init(PQerrormsg);
 373         if (ret != STATUS_OK)
 374                 return ret;
 375
 376         retval = krb5_sname_to_principal(pg_krb5_context, hostname, PG_KRB_SRVNAM,
 377                                                                          KRB5_NT_SRV_HST, &server);
 378         if (retval)
 379         {
 380                 snprintf(PQerrormsg, PQERRORMSG_LENGTH,
 381                                  "pg_krb5_sendauth: krb5_sname_to_principal: %s\n",
 382                                  error_message(retval));
 383                 return STATUS_ERROR;
 384         }
 385
 386         /*
 387          * libpq uses a non-blocking socket. But kerberos needs a blocking
 388          * socket, and we have to block somehow to do mutual authentication
 389          * anyway. So we temporarily make it blocking.
 390          */
 391         flags = fcntl(sock, F_GETFL);
 392         if (flags < 0 || fcntl(sock, F_SETFL, (long) (flags & ~O_NONBLOCK)))
 393         {
 394                 char            sebuf[256];
 395
 396                 snprintf(PQerrormsg, PQERRORMSG_LENGTH,
 397                                  libpq_gettext("could not set socket to blocking mode: %s\n"), pqStrerror(errno, sebuf, sizeof(sebuf)));
 398                 krb5_free_principal(pg_krb5_context, server);
 399                 return STATUS_ERROR;
 400         }
 401
 402         retval = krb5_sendauth(pg_krb5_context, &auth_context,
 403                                                    (krb5_pointer) & sock, PG_KRB_SRVNAM,
 404                                                    pg_krb5_client, server,
 405                                                    AP_OPTS_MUTUAL_REQUIRED,
 406                                                    NULL, 0,             /* no creds, use ccache instead */
 407                                                    pg_krb5_ccache, &err_ret, NULL, NULL);
 408         if (retval)
 409         {
 410                 if (retval == KRB5_SENDAUTH_REJECTED && err_ret)
 411                 {
 412 #if defined(HAVE_KRB5_ERROR_TEXT_DATA)
 413                         snprintf(PQerrormsg, PQERRORMSG_LENGTH,
 414                           libpq_gettext("Kerberos 5 authentication rejected: %*s\n"),
 415                                          (int) err_ret->text.length, err_ret->text.data);
 416 #elif defined(HAVE_KRB5_ERROR_E_DATA)
 417                         snprintf(PQerrormsg, PQERRORMSG_LENGTH,
 418                           libpq_gettext("Kerberos 5 authentication rejected: %*s\n"),
 419                                          (int) err_ret->e_data->length,
 420                                          (const char *) err_ret->e_data->data);
 421 #else
 422 #error "bogus configuration"
 423 #endif
 424                 }
 425                 else
 426                 {
 427                         snprintf(PQerrormsg, PQERRORMSG_LENGTH,
 428                                          "krb5_sendauth: %s\n", error_message(retval));
 429                 }
 430
 431                 if (err_ret)
 432                         krb5_free_error(pg_krb5_context, err_ret);
 433
 434                 ret = STATUS_ERROR;
 435         }
 436
 437         krb5_free_principal(pg_krb5_context, server);
 438
 439         if (fcntl(sock, F_SETFL, (long) flags))
 440         {
 441                 char            sebuf[256];
 442
 443                 snprintf(PQerrormsg, PQERRORMSG_LENGTH,
 444                                  libpq_gettext("could not restore non-blocking mode on socket: %s\n"),
 445                                  pqStrerror(errno, sebuf, sizeof(sebuf)));
 446                 ret = STATUS_ERROR;
 447         }
 448
 449         return ret;
 450 }
 451 #endif   /* KRB5 */
 452
 453 /*
 454  * Respond to AUTH_REQ_SCM_CREDS challenge.
 455  *
 456  * Note: current backends will not use this challenge if HAVE_GETPEEREID
 457  * or SO_PEERCRED is defined, but pre-7.4 backends might, so compile the
 458  * code anyway.
 459  */
 460 static int
 461 pg_local_sendauth(char *PQerrormsg, PGconn *conn)
 462 {
 463 #if defined(HAVE_STRUCT_CMSGCRED) || defined(HAVE_STRUCT_FCRED) || \
 464         (defined(HAVE_STRUCT_SOCKCRED) && defined(LOCAL_CREDS))
 465         char            buf;
 466         struct iovec iov;
 467         struct msghdr msg;
 468
 469 #ifdef HAVE_STRUCT_CMSGCRED
 470         /* Prevent padding */
 471         char            cmsgmem[sizeof(struct cmsghdr) + sizeof(struct cmsgcred)];
 472
 473         /* Point to start of first structure */
 474         struct cmsghdr *cmsg = (struct cmsghdr *) cmsgmem;
 475 #endif
 476
 477         /*
 478          * The backend doesn't care what we send here, but it wants exactly
 479          * one character to force recvmsg() to block and wait for us.
 480          */
 481         buf = '\0';
 482         iov.iov_base = &buf;
 483         iov.iov_len = 1;
 484
 485         memset(&msg, 0, sizeof(msg));
 486         msg.msg_iov = &iov;
 487         msg.msg_iovlen = 1;
 488
 489 #ifdef HAVE_STRUCT_CMSGCRED
 490         /* Create control header, FreeBSD */
 491         msg.msg_control = cmsg;
 492         msg.msg_controllen = sizeof(cmsgmem);
 493         memset(cmsg, 0, sizeof(cmsgmem));
 494         cmsg->cmsg_len = sizeof(cmsgmem);
 495         cmsg->cmsg_level = SOL_SOCKET;
 496         cmsg->cmsg_type = SCM_CREDS;
 497 #endif
 498
 499         if (sendmsg(conn->sock, &msg, 0) == -1)
 500         {
 501                 char            sebuf[256];
 502
 503                 snprintf(PQerrormsg, PQERRORMSG_LENGTH,
 504                                  "pg_local_sendauth: sendmsg: %s\n",
 505                                  pqStrerror(errno, sebuf, sizeof(sebuf)));
 506                 return STATUS_ERROR;
 507         }
 508         return STATUS_OK;
 509 #else
 510         snprintf(PQerrormsg, PQERRORMSG_LENGTH,
 511                 libpq_gettext("SCM_CRED authentication method not supported\n"));
 512         return STATUS_ERROR;
 513 #endif
 514 }
 515
 516 static int
 517 pg_password_sendauth(PGconn *conn, const char *password, AuthRequest areq)
 518 {
 519         int                     ret;
 520         char       *crypt_pwd;
 521
 522         /* Encrypt the password if needed. */
 523
 524         switch (areq)
 525         {
 526                 case AUTH_REQ_MD5:
 527                         {
 528                                 char       *crypt_pwd2;
 529
 530                                 if (!(crypt_pwd = malloc(MD5_PASSWD_LEN + 1)) ||
 531                                         !(crypt_pwd2 = malloc(MD5_PASSWD_LEN + 1)))
 532                                 {
 533                                         fprintf(stderr, libpq_gettext("out of memory\n"));
 534                                         return STATUS_ERROR;
 535                                 }
 536                                 if (!EncryptMD5(password, conn->pguser,
 537                                                                 strlen(conn->pguser), crypt_pwd2))
 538                                 {
 539                                         free(crypt_pwd);
 540                                         free(crypt_pwd2);
 541                                         return STATUS_ERROR;
 542                                 }
 543                                 if (!EncryptMD5(crypt_pwd2 + strlen("md5"), conn->md5Salt,
 544                                                                 sizeof(conn->md5Salt), crypt_pwd))
 545                                 {
 546                                         free(crypt_pwd);
 547                                         free(crypt_pwd2);
 548                                         return STATUS_ERROR;
 549                                 }
 550                                 free(crypt_pwd2);
 551                                 break;
 552                         }
 553                 case AUTH_REQ_CRYPT:
 554                         {
 555                                 char            salt[3];
 556
 557                                 StrNCpy(salt, conn->cryptSalt, 3);
 558                                 crypt_pwd = crypt(password, salt);
 559                                 break;
 560                         }
 561                 case AUTH_REQ_PASSWORD:
 562                         /* discard const so we can assign it */
 563                         crypt_pwd = (char *) password;
 564                         break;
 565                 default:
 566                         return STATUS_ERROR;
 567         }
 568         /* Packet has a message type as of protocol 3.0 */
 569         if (PG_PROTOCOL_MAJOR(conn->pversion) >= 3)
 570                 ret = pqPacketSend(conn, 'p', crypt_pwd, strlen(crypt_pwd) + 1);
 571         else
 572                 ret = pqPacketSend(conn, 0, crypt_pwd, strlen(crypt_pwd) + 1);
 573         if (areq == AUTH_REQ_MD5)
 574                 free(crypt_pwd);
 575         return ret;
 576 }
 577
 578 /*
 579  * fe_sendauth -- client demux routine for outgoing authentication information
 580  */
 581 int
 582 fe_sendauth(AuthRequest areq, PGconn *conn, const char *hostname,
 583                         const char *password, char *PQerrormsg)
 584 {
 585 #if !defined(KRB4) && !defined(KRB5)
 586         (void) hostname;                        /* not used */
 587 #endif
 588
 589         switch (areq)
 590         {
 591                 case AUTH_REQ_OK:
 592                         break;
 593
 594                 case AUTH_REQ_KRB4:
 595 #ifdef KRB4
 596                         pglock_thread();
 597                         if (pg_krb4_sendauth(PQerrormsg, conn->sock,
 598                                                            (struct sockaddr_in *) & conn->laddr.addr,
 599                                                            (struct sockaddr_in *) & conn->raddr.addr,
 600                                                                  hostname) != STATUS_OK)
 601                         {
 602                                 snprintf(PQerrormsg, PQERRORMSG_LENGTH,
 603                                         libpq_gettext("Kerberos 4 authentication failed\n"));
 604                                 pgunlock_thread();
 605                                 return STATUS_ERROR;
 606                         }
 607                         pgunlock_thread();
 608                         break;
 609 #else
 610                         snprintf(PQerrormsg, PQERRORMSG_LENGTH,
 611                          libpq_gettext("Kerberos 4 authentication not supported\n"));
 612                         return STATUS_ERROR;
 613 #endif
 614
 615                 case AUTH_REQ_KRB5:
 616 #ifdef KRB5
 617                         pglock_thread();
 618                         if (pg_krb5_sendauth(PQerrormsg, conn->sock,
 619                                                                  hostname) != STATUS_OK)
 620                         {
 621                                 snprintf(PQerrormsg, PQERRORMSG_LENGTH,
 622                                         libpq_gettext("Kerberos 5 authentication failed\n"));
 623                                 pgunlock_thread();
 624                                 return STATUS_ERROR;
 625                         }
 626                         pgunlock_thread();
 627                         break;
 628 #else
 629                         snprintf(PQerrormsg, PQERRORMSG_LENGTH,
 630                          libpq_gettext("Kerberos 5 authentication not supported\n"));
 631                         return STATUS_ERROR;
 632 #endif
 633
 634                 case AUTH_REQ_MD5:
 635                 case AUTH_REQ_CRYPT:
 636                 case AUTH_REQ_PASSWORD:
 637                         if (password == NULL || *password == '\0')
 638                         {
 639                                 (void) snprintf(PQerrormsg, PQERRORMSG_LENGTH,
 640                                                                 PQnoPasswordSupplied);
 641                                 return STATUS_ERROR;
 642                         }
 643                         if (pg_password_sendauth(conn, password, areq) != STATUS_OK)
 644                         {
 645                                 (void) snprintf(PQerrormsg, PQERRORMSG_LENGTH,
 646                                  "fe_sendauth: error sending password authentication\n");
 647                                 return STATUS_ERROR;
 648                         }
 649                         break;
 650
 651                 case AUTH_REQ_SCM_CREDS:
 652                         if (pg_local_sendauth(PQerrormsg, conn) != STATUS_OK)
 653                                 return STATUS_ERROR;
 654                         break;
 655
 656                 default:
 657                         snprintf(PQerrormsg, PQERRORMSG_LENGTH,
 658                                          libpq_gettext("authentication method %u not supported\n"), areq);
 659                         return STATUS_ERROR;
 660         }
 661
 662         return STATUS_OK;
 663 }
 664
 665 /*
 666  * fe_setauthsvc
 667  * fe_getauthsvc
 668  *
 669  * Set/return the authentication service currently selected for use by the
 670  * frontend. (You can only use one in the frontend, obviously.)
 671  *
 672  * NB: This is not thread-safe if different threads try to select different
 673  * authentication services!  It's OK for fe_getauthsvc to select the default,
 674  * since that will be the same for all threads, but direct application use
 675  * of fe_setauthsvc is not thread-safe.  However, use of fe_setauthsvc is
 676  * deprecated anyway...
 677  */
 678
 679 static int      pg_authsvc = -1;
 680
 681 void
 682 fe_setauthsvc(const char *name, char *PQerrormsg)
 683 {
 684         int                     i;
 685
 686         for (i = 0; i < n_authsvcs; ++i)
 687                 if (strcmp(name, authsvcs[i].name) == 0)
 688                 {
 689                         pg_authsvc = i;
 690                         break;
 691                 }
 692         if (i == n_authsvcs)
 693         {
 694                 snprintf(PQerrormsg, PQERRORMSG_LENGTH,
 695                                  libpq_gettext("invalid authentication service name \"%s\", ignored\n"),
 696                                  name);
 697         }
 698         return;
 699 }
 700
 701 MsgType
 702 fe_getauthsvc(char *PQerrormsg)
 703 {
 704         if (pg_authsvc < 0 || pg_authsvc >= n_authsvcs)
 705         {
 706                 fe_setauthsvc(DEFAULT_CLIENT_AUTHSVC, PQerrormsg);
 707                 if (pg_authsvc < 0 || pg_authsvc >= n_authsvcs)
 708                 {
 709                         /* Can only get here if DEFAULT_CLIENT_AUTHSVC is misdefined */
 710                         return 0;
 711                 }
 712         }
 713         return authsvcs[pg_authsvc].msgtype;
 714 }
 715
 716 /*
 717  * fe_getauthname -- returns a pointer to dynamic space containing whatever
 718  *                                       name the user has authenticated to the system
 719  * if there is an error, return the error message in PQerrormsg
 720  */
 721 char *
 722 fe_getauthname(char *PQerrormsg)
 723 {
 724         const char *name = NULL;
 725         char       *authn;
 726         MsgType         authsvc;
 727 #ifdef WIN32
 728         char            username[128];
 729         DWORD           namesize = sizeof(username) - 1;
 730 #else
 731         char            pwdbuf[BUFSIZ];
 732         struct passwd pwdstr;
 733         struct passwd *pw = NULL;
 734 #endif
 735
 736         authsvc = fe_getauthsvc(PQerrormsg);
 737
 738         /* this just guards against broken DEFAULT_CLIENT_AUTHSVC, see above */
 739         if (authsvc == 0)
 740                 return NULL;                    /* leave original error message in place */
 741
 742         pglock_thread();
 743
 744 #ifdef KRB4
 745         if (authsvc == STARTUP_KRB4_MSG)
 746                 name = pg_krb4_authname(PQerrormsg);
 747 #endif
 748 #ifdef KRB5
 749         if (authsvc == STARTUP_KRB5_MSG)
 750                 name = pg_krb5_authname(PQerrormsg);
 751 #endif
 752
 753         if (authsvc == STARTUP_MSG
 754                 || (authsvc == STARTUP_KRB4_MSG && !name)
 755                 || (authsvc == STARTUP_KRB5_MSG && !name))
 756         {
 757 #ifdef WIN32
 758                 if (GetUserName(username, &namesize))
 759                         name = username;
 760 #else
 761                 if (pqGetpwuid(geteuid(), &pwdstr, pwdbuf, sizeof(pwdbuf), &pw) == 0)
 762                         name = pw->pw_name;
 763 #endif
 764         }
 765
 766         if (authsvc != STARTUP_MSG && authsvc != STARTUP_KRB4_MSG && authsvc != STARTUP_KRB5_MSG)
 767                 snprintf(PQerrormsg, PQERRORMSG_LENGTH,
 768                                  libpq_gettext("fe_getauthname: invalid authentication system: %d\n"),
 769                                  authsvc);
 770
 771         authn = name ? strdup(name) : NULL;
 772
 773         pgunlock_thread();
 774
 775         return authn;
 776 }