开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > 查看源码
hba.c
资源名称：postgresql-6.5.2.tar.gz　[点击查看]
上传用户：blenddy
上传日期：2007-01-07
资源大小：6495k
文件大小：28k
源码类别：

数据库系统

开发平台：

Unix_Linux

hba.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * hba.c
  4.  *   Routines to handle host based authentication (that's the scheme
  5.  *   wherein you authenticate a user by seeing what IP address the system
  6.  *   says he comes from and possibly using ident).
  7.  *
  8.  * $Id: hba.c,v 1.43 1999/05/25 16:08:59 momjian Exp $
  9.  *
  10.  *-------------------------------------------------------------------------
  11.  */
  12. #include <stdio.h>
  13. #include <string.h>
  14. #include <errno.h>
  15. #include <pwd.h>
  16. #include <sys/types.h>
  17. #include <fcntl.h>
  18. #include <sys/socket.h>
  19. #include <netinet/in.h>
  20. #include <arpa/inet.h>
  21. #include <unistd.h>
  23. #include <postgres.h>
  24. #include <miscadmin.h>
  25. #include <libpq/libpq.h>
  26. #include <libpq/pqcomm.h>
  27. #include <libpq/hba.h>
  28. #include <port/inet_aton.h> /* For inet_aton() */
  29. #include <storage/fd.h>
  31. /* Some standard C libraries, including GNU, have an isblank() function.
  32.    Others, including Solaris, do not.  So we have our own.
  33. */
  34. static bool
  35. isblank(const char c)
  36. {
  37. return c == ' ' || c == 9 /* tab */ ;
  38. }
  42. static void
  43. next_token(FILE *fp, char *buf, const int bufsz)
  44. {
  45. /*--------------------------------------------------------------------------
  46.   Grab one token out of fp.  Tokens are strings of non-blank
  47.   characters bounded by blank characters, beginning of line, and end
  48.   of line. Blank means space or tab.  Return the token as *buf.
  49.   Leave file positioned to character immediately after the token or
  50.   EOF, whichever comes first.  If no more tokens on line, return null
  51.   string as *buf and position file to beginning of next line or EOF,
  52.   whichever comes first.
  53. --------------------------------------------------------------------------*/
  54. int c;
  55. char    *eb = buf + (bufsz - 1);
  57. /* Move over inital token-delimiting blanks */
  58. while (isblank(c = getc(fp)));
  60. if (c != 'n')
  61. {
  63. /*
  64.  * build a token in buf of next characters up to EOF, eol, or
  65.  * blank.
  66.  */
  67. while (c != EOF && c != 'n' && !isblank(c))
  68. {
  69. if (buf < eb)
  70. *buf++ = c;
  71. c = getc(fp);
  73. /*
  74.  * Put back the char right after the token (putting back EOF
  75.  * is ok)
  76.  */
  77. }
  78. ungetc(c, fp);
  79. }
  80. *buf = '';
  81. }
  85. static void
  86. read_through_eol(FILE *file)
  87. {
  88. int c;
  90. do
  91. c = getc(file);
  92. while (c != 'n' && c != EOF);
  93. }
  97. static void
  98. read_hba_entry2(FILE *file, UserAuth *userauth_p, char *auth_arg,
  99. bool *error_p)
  100. {
  101. /*--------------------------------------------------------------------------
  102.   Read from file FILE the rest of a host record, after the mask field,
  103.   and return the interpretation of it as *userauth_p, auth_arg, and
  104.   *error_p.
  105. ---------------------------------------------------------------------------*/
  106. char buf[MAX_TOKEN];
  108. /* Get authentication type token. */
  109. next_token(file, buf, sizeof(buf));
  111. if (strcmp(buf, "trust") == 0)
  112. *userauth_p = uaTrust;
  113. else if (strcmp(buf, "ident") == 0)
  114. *userauth_p = uaIdent;
  115. else if (strcmp(buf, "password") == 0)
  116. *userauth_p = uaPassword;
  117. else if (strcmp(buf, "krb4") == 0)
  118. *userauth_p = uaKrb4;
  119. else if (strcmp(buf, "krb5") == 0)
  120. *userauth_p = uaKrb5;
  121. else if (strcmp(buf, "reject") == 0)
  122. *userauth_p = uaReject;
  123. else if (strcmp(buf, "crypt") == 0)
  124. *userauth_p = uaCrypt;
  125. else
  126. {
  127. *error_p = true;
  129. if (buf[0] != '')
  130. read_through_eol(file);
  131. }
  133. if (!*error_p)
  134. {
  135. /* Get the authentication argument token, if any */
  136. next_token(file, buf, sizeof(buf));
  137. if (buf[0] == '')
  138. auth_arg[0] = '';
  139. else
  140. {
  141. StrNCpy(auth_arg, buf, MAX_AUTH_ARG - 1);
  142. next_token(file, buf, sizeof(buf));
  143. if (buf[0] != '')
  144. {
  145. *error_p = true;
  146. read_through_eol(file);
  147. }
  148. }
  149. }
  150. }
  154. static void
  155. process_hba_record(FILE *file, SockAddr *raddr, const char *user,
  156.    const char *database, bool *matches_p, bool *error_p,
  157.    UserAuth *userauth_p, char *auth_arg)
  158. {
  159. /*---------------------------------------------------------------------------
  160.   Process the non-comment record in the config file that is next on the file.
  161.   See if it applies to a connection to a host with IP address "*raddr"
  162.   to a database named "*database". If so, return *matches_p true
  163.   and *userauth_p and *auth_arg as the values from the entry.
  164.   If not, leave *matches_p as it was.  If the record has a syntax error,
  165.   return *error_p true, after issuing a message to stderr. If no error,
  166.   leave *error_p as it was.
  167. ---------------------------------------------------------------------------*/
  168. char db[MAX_TOKEN],
  169. buf[MAX_TOKEN];
  171. /* Read the record type field. */
  173. next_token(file, buf, sizeof(buf));
  175. if (buf[0] == '')
  176. return;
  178. /* Check the record type. */
  180. if (strcmp(buf, "local") == 0)
  181. {
  182. /* Get the database. */
  184. next_token(file, db, sizeof(db));
  186. if (db[0] == '')
  187. goto syntax;
  189. /* Read the rest of the line. */
  191. read_hba_entry2(file, userauth_p, auth_arg, error_p);
  193. /*
  194.  * For now, disallow methods that need AF_INET sockets to work.
  195.  */
  197. if (!*error_p &&
  198. (*userauth_p == uaIdent ||
  199.  *userauth_p == uaKrb4 ||
  200.  *userauth_p == uaKrb5))
  201. *error_p = true;
  203. if (*error_p)
  204. goto syntax;
  206. /*
  207.  * If this record isn't for our database, or this is the wrong
  208.  * sort of connection, ignore it.
  209.  */
  211. if ((strcmp(db, database) != 0 && strcmp(db, "all") != 0 &&
  212.  (strcmp(db, "sameuser") != 0 || strcmp(database, user) != 0)) ||
  213. raddr->sa.sa_family != AF_UNIX)
  214. return;
  215. }
  216. else if (strcmp(buf, "host") == 0)
  217. {
  218. struct in_addr file_ip_addr,
  219. mask;
  221. /* Get the database. */
  223. next_token(file, db, sizeof(db));
  225. if (db[0] == '')
  226. goto syntax;
  228. /* Read the IP address field. */
  230. next_token(file, buf, sizeof(buf));
  232. if (buf[0] == '')
  233. goto syntax;
  235. /* Remember the IP address field and go get mask field. */
  237. if (!inet_aton(buf, &file_ip_addr))
  238. {
  239. read_through_eol(file);
  240. goto syntax;
  241. }
  243. /* Read the mask field. */
  245. next_token(file, buf, sizeof(buf));
  247. if (buf[0] == '')
  248. goto syntax;
  250. if (!inet_aton(buf, &mask))
  251. {
  252. read_through_eol(file);
  253. goto syntax;
  254. }
  256. /*
  257.  * This is the record we're looking for.  Read the rest of the
  258.  * info from it.
  259.  */
  261. read_hba_entry2(file, userauth_p, auth_arg, error_p);
  263. if (*error_p)
  264. goto syntax;
  266. /*
  267.  * If this record isn't for our database, or this is the wrong
  268.  * sort of connection, ignore it.
  269.  */
  271. if ((strcmp(db, database) != 0 && strcmp(db, "all") != 0 &&
  272.  (strcmp(db, "sameuser") != 0 || strcmp(database, user) != 0)) ||
  273. raddr->sa.sa_family != AF_INET ||
  274. ((file_ip_addr.s_addr ^ raddr->in.sin_addr.s_addr) & mask.s_addr) != 0x0000)
  275. return;
  276. }
  277. else
  278. {
  279. read_through_eol(file);
  280. goto syntax;
  281. }
  283. *matches_p = true;
  285. return;
  287. syntax:
  288. snprintf(PQerrormsg, ERROR_MSG_LENGTH,
  289.  "process_hba_record: invalid syntax in pg_hba.conf filen");
  291. fputs(PQerrormsg, stderr);
  292. pqdebug("%s", PQerrormsg);
  294. *error_p = true;
  295. }
  299. static void
  300. process_open_config_file(FILE *file, SockAddr *raddr, const char *user,
  301.  const char *database, bool *hba_ok_p,
  302.  UserAuth *userauth_p, char *auth_arg)
  303. {
  304. /*---------------------------------------------------------------------------
  305.   This function does the same thing as find_hba_entry, only with
  306.   the config file already open on stream descriptor "file".
  307. ----------------------------------------------------------------------------*/
  308. bool found_entry = false; /* found an applicable entry? */
  309. bool error = false; /* found an erroneous entry? */
  310. bool eof = false; /* end of hba file */
  312. while (!eof && !found_entry && !error)
  313. {
  314. /* Process a line from the config file */
  315. int c = getc(file);
  317. if (c == EOF)
  318. eof = true;
  319. else
  320. {
  321. ungetc(c, file);
  322. if (c == '#')
  323. read_through_eol(file);
  324. else
  325. process_hba_record(file, raddr, user, database,
  326.  &found_entry, &error, userauth_p, auth_arg);
  327. }
  328. }
  330. if (!error)
  331. {
  332. /* If no matching entry was found, synthesize 'reject' entry. */
  334. if (!found_entry)
  335. *userauth_p = uaReject;
  337. *hba_ok_p = true;
  338. }
  339. }
  343. static void
  344. find_hba_entry(SockAddr *raddr, const char *user, const char *database,
  345.    bool *hba_ok_p, UserAuth *userauth_p, char *auth_arg)
  346. {
  347. /*
  348.  * Read the config file and find an entry that allows connection from
  349.  * host "raddr", user "user", to database "database".  If found,
  350.  * return *hba_ok_p = true and *userauth_p and *auth_arg representing
  351.  * the contents of that entry. If there is no matching entry, we
  352.  * set *hba_ok_p = true, *userauth_p = uaReject.
  353.  *
  354.  * If the config file is unreadable or contains invalid syntax, we
  355.  * issue a diagnostic message to stderr (ie, the postmaster log file)
  356.  * and return without changing *hba_ok_p.
  357.  *
  358.  * If we find a file by the old name of the config file (pg_hba), we issue
  359.  * an error message because it probably needs to be converted. He didn't
  360.  * follow directions and just installed his old hba file in the new database
  361.  * system.
  362.  */
  364. int fd,
  365. bufsize;
  366. FILE    *file; /* The config file we have to read */
  367. char    *old_conf_file;
  369. /* The name of old config file that better not exist. */
  371. /* Fail if config file by old name exists. */
  374. /* put together the full pathname to the old config file */
  375. bufsize = (strlen(DataDir) + strlen(OLD_CONF_FILE) + 2) * sizeof(char);
  376. old_conf_file = (char *) palloc(bufsize);
  377. snprintf(old_conf_file, bufsize, "%s/%s", DataDir, OLD_CONF_FILE);
  379. #ifndef __CYGWIN32__
  380. if ((fd = open(old_conf_file, O_RDONLY, 0)) != -1)
  381. #else
  382. if ((fd = open(old_conf_file, O_RDONLY | O_BINARY, 0)) != -1)
  383. #endif
  384. {
  385. /* Old config file exists. Tell this guy he needs to upgrade. */
  386. close(fd);
  387. snprintf(PQerrormsg, ERROR_MSG_LENGTH,
  388.   "A file exists by the name used for host-based authentication "
  389.    "in prior releases of Postgres (%s).  The name and format of "
  390.    "the configuration file have changed, so this file should be "
  391.  "converted.n",
  392.  old_conf_file);
  393. fputs(PQerrormsg, stderr);
  394. pqdebug("%s", PQerrormsg);
  395. }
  396. else
  397. {
  398. char    *conf_file; /* The name of the config file we have to
  399.  * read */
  401. /* put together the full pathname to the config file */
  402. bufsize = (strlen(DataDir) + strlen(CONF_FILE) + 2) * sizeof(char);
  403. conf_file = (char *) palloc(bufsize);
  404. snprintf(conf_file, bufsize, "%s/%s", DataDir, CONF_FILE);
  406. file = AllocateFile(conf_file, "r");
  407. if (file == NULL)
  408. {
  409. /* The open of the config file failed. */
  411. snprintf(PQerrormsg, ERROR_MSG_LENGTH,
  412.  "find_hba_entry: Host-based authentication config file "
  413. "does not exist or permissions are not setup correctly! "
  414.  "Unable to open file "%s".n",
  415.  conf_file);
  416. fputs(PQerrormsg, stderr);
  417. pqdebug("%s", PQerrormsg);
  418. }
  419. else
  420. {
  421. process_open_config_file(file, raddr, user, database, hba_ok_p,
  422.  userauth_p, auth_arg);
  423. FreeFile(file);
  424. }
  425. pfree(conf_file);
  426. }
  427. pfree(old_conf_file);
  428. }
  431. static void
  432. interpret_ident_response(char *ident_response,
  433.  bool *error_p, char *ident_username)
  434. {
  435. /*----------------------------------------------------------------------------
  436.   Parse the string "*ident_response" as a response from a query to an Ident
  437.   server.  If it's a normal response indicating a username, return
  438.   *error_p == false and the username as *ident_username.  If it's anything
  439.   else, return *error_p == true and *ident_username undefined.
  440. ----------------------------------------------------------------------------*/
  441. char    *cursor; /* Cursor into *ident_response */
  443. cursor = &ident_response[0];
  445. /*
  446.  * Ident's response, in the telnet tradition, should end in crlf
  447.  * (rn).
  448.  */
  449. if (strlen(ident_response) < 2)
  450. *error_p = true;
  451. else if (ident_response[strlen(ident_response) - 2] != 'r')
  452. *error_p = true;
  453. else
  454. {
  455. while (*cursor != ':' && *cursor != 'r')
  456. cursor++; /* skip port field */
  458. if (*cursor != ':')
  459. *error_p = true;
  460. else
  461. {
  462. /* We're positioned to colon before response type field */
  463. char response_type[80];
  464. int i; /* Index into *response_type */
  466. cursor++; /* Go over colon */
  467. while (isblank(*cursor))
  468. cursor++; /* skip blanks */
  469. i = 0;
  470. while (*cursor != ':' && *cursor != 'r' && !isblank(*cursor)
  471.    && i < sizeof(response_type) - 1)
  472. response_type[i++] = *cursor++;
  473. response_type[i] = '';
  474. while (isblank(*cursor))
  475. cursor++; /* skip blanks */
  476. if (strcmp(response_type, "USERID") != 0)
  477. *error_p = true;
  478. else
  479. {
  481. /*
  482.  * It's a USERID response.  Good.  "cursor" should be
  483.  * pointing to the colon that precedes the operating
  484.  * system type.
  485.  */
  486. if (*cursor != ':')
  487. *error_p = true;
  488. else
  489. {
  490. cursor++; /* Go over colon */
  491. /* Skip over operating system field. */
  492. while (*cursor != ':' && *cursor != 'r')
  493. cursor++;
  494. if (*cursor != ':')
  495. *error_p = true;
  496. else
  497. {
  498. int i; /* Index into *ident_username */
  500. cursor++; /* Go over colon */
  501. while (isblank(*cursor))
  502. cursor++; /* skip blanks */
  503. /* Rest of line is username.  Copy it over. */
  504. i = 0;
  505. while (*cursor != 'r' && i < IDENT_USERNAME_MAX)
  506. ident_username[i++] = *cursor++;
  507. ident_username[i] = '';
  508. *error_p = false;
  509. }
  510. }
  511. }
  512. }
  513. }
  514. }
  518. static void
  519. ident(const struct in_addr remote_ip_addr, const struct in_addr local_ip_addr,
  520.   const ushort remote_port, const ushort local_port,
  521.   bool *ident_failed, char *ident_username)
  522. {
  523. /*--------------------------------------------------------------------------
  524.   Talk to the ident server on host "remote_ip_addr" and find out who
  525.   owns the tcp connection from his port "remote_port" to port
  526.   "local_port_addr" on host "local_ip_addr".  Return the username the
  527.   ident server gives as "*ident_username".
  529.   IP addresses and port numbers are in network byte order.
  531.   But iff we're unable to get the information from ident, return
  532.   *ident_failed == true (and *ident_username undefined).
  533. ----------------------------------------------------------------------------*/
  536. int sock_fd, /* File descriptor for socket on which we
  537.  * talk to Ident */
  538. rc; /* Return code from a locally called
  539.  * function */
  541. sock_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
  542. if (sock_fd == -1)
  543. {
  544. snprintf(PQerrormsg, ERROR_MSG_LENGTH,
  545.  "Failed to create socket on which to talk to Ident server. "
  546.  "socket() returned errno = %s (%d)n",
  547.  strerror(errno), errno);
  548. fputs(PQerrormsg, stderr);
  549. pqdebug("%s", PQerrormsg);
  550. }
  551. else
  552. {
  553. struct sockaddr_in ident_server;
  554. struct sockaddr_in la;
  556. /*
  557.  * Socket address of Ident server on the system from which client
  558.  * is attempting to connect to us.
  559.  */
  560. ident_server.sin_family = AF_INET;
  561. ident_server.sin_port = htons(IDENT_PORT);
  562. ident_server.sin_addr = remote_ip_addr;
  564. /*
  565.  * Bind to the address which the client originally contacted,
  566.  * otherwise the ident server won't be able to match up the right
  567.  * connection. This is necessary if the PostgreSQL server is
  568.  * running on an IP alias.
  569.  */
  570. memset(&la, 0, sizeof(la));
  571. la.sin_family = AF_INET;
  572. la.sin_addr = local_ip_addr;
  573. rc = bind(sock_fd, (struct sockaddr *) & la, sizeof(la));
  574. if (rc == 0)
  575. {
  576. rc = connect(sock_fd,
  577.    (struct sockaddr *) & ident_server, sizeof(ident_server));
  578. }
  579. if (rc != 0)
  580. {
  581. snprintf(PQerrormsg, ERROR_MSG_LENGTH,
  582. "Unable to connect to Ident server on the host which is "
  583.  "trying to connect to Postgres "
  584.  "(IP address %s, Port %d). "
  585.  "errno = %s (%d)n",
  586.  inet_ntoa(remote_ip_addr), IDENT_PORT, strerror(errno), errno);
  587. fputs(PQerrormsg, stderr);
  588. pqdebug("%s", PQerrormsg);
  589. *ident_failed = true;
  590. }
  591. else
  592. {
  593. char ident_query[80];
  595. /* The query we send to the Ident server */
  596. snprintf(ident_query, 80, "%d,%dn",
  597.  ntohs(remote_port), ntohs(local_port));
  598. rc = send(sock_fd, ident_query, strlen(ident_query), 0);
  599. if (rc < 0)
  600. {
  601. snprintf(PQerrormsg, ERROR_MSG_LENGTH,
  602.  "Unable to send query to Ident server on the host which is "
  603.   "trying to connect to Postgres (Host %s, Port %d),"
  604.  "even though we successfully connected to it.  "
  605.  "errno = %s (%d)n",
  606.  inet_ntoa(remote_ip_addr), IDENT_PORT, strerror(errno), errno);
  607. fputs(PQerrormsg, stderr);
  608. pqdebug("%s", PQerrormsg);
  609. *ident_failed = true;
  610. }
  611. else
  612. {
  613. char ident_response[80 + IDENT_USERNAME_MAX];
  615. rc = recv(sock_fd, ident_response, sizeof(ident_response) - 1, 0);
  616. if (rc < 0)
  617. {
  618. snprintf(PQerrormsg, ERROR_MSG_LENGTH,
  619.   "Unable to receive response from Ident server "
  620.  "on the host which is "
  621.   "trying to connect to Postgres (Host %s, Port %d),"
  622. "even though we successfully sent our query to it.  "
  623.  "errno = %s (%d)n",
  624.  inet_ntoa(remote_ip_addr), IDENT_PORT,
  625.  strerror(errno), errno);
  626. fputs(PQerrormsg, stderr);
  627. pqdebug("%s", PQerrormsg);
  628. *ident_failed = true;
  629. }
  630. else
  631. {
  632. bool error; /* response from Ident is garbage. */
  634. ident_response[rc] = '';
  635. interpret_ident_response(ident_response, &error, ident_username);
  636. *ident_failed = error;
  637. }
  638. }
  639. close(sock_fd);
  640. }
  641. }
  642. }
  646. static void
  647. parse_map_record(FILE *file,
  648.  char *file_map, char *file_pguser, char *file_iuser)
  649. {
  650. /*---------------------------------------------------------------------------
  651.   Take the noncomment line which is next on file "file" and interpret
  652.   it as a line in a usermap file.  Specifically, return the first
  653.   3 tokens as file_map, file_iuser, and file_pguser, respectively. If
  654.   there are fewer than 3 tokens, return null strings for the missing
  655.   ones.
  657. ---------------------------------------------------------------------------*/
  658. char buf[MAX_TOKEN];
  660. /* A token read from the file */
  662. /* Set defaults in case fields not in file */
  663. file_map[0] = '';
  664. file_pguser[0] = '';
  665. file_iuser[0] = '';
  667. next_token(file, buf, sizeof(buf));
  668. if (buf[0] != '')
  669. {
  670. strcpy(file_map, buf);
  671. next_token(file, buf, sizeof(buf));
  672. if (buf[0] != '')
  673. {
  674. strcpy(file_iuser, buf);
  675. next_token(file, buf, sizeof(buf));
  676. if (buf[0] != '')
  677. {
  678. strcpy(file_pguser, buf);
  679. read_through_eol(file);
  680. return;
  681. }
  682. }
  683. snprintf(PQerrormsg, ERROR_MSG_LENGTH,
  684.  "Incomplete line in pg_ident: %s", file_map);
  685. fputs(PQerrormsg, stderr);
  686. pqdebug("%s", PQerrormsg);
  687. }
  688. }
  692. static void
  693. verify_against_open_usermap(FILE *file,
  694. const char *pguser,
  695. const char *ident_username,
  696. const char *usermap_name,
  697. bool *checks_out_p)
  698. {
  699. /*--------------------------------------------------------------------------
  700.   This function does the same thing as verify_against_usermap,
  701.   only with the config file already open on stream descriptor "file".
  702. ---------------------------------------------------------------------------*/
  703. bool match; /* We found a matching entry in the map
  704.  * file */
  705. bool eof; /* We've reached the end of the file we're
  706.  * reading */
  708. match = false; /* initial value */
  709. eof = false; /* initial value */
  710. while (!eof && !match)
  711. {
  712. /* Process a line from the map file */
  714. int c; /* a character read from the file */
  716. c = getc(file);
  717. ungetc(c, file);
  718. if (c == EOF)
  719. eof = true;
  720. else
  721. {
  722. if (c == '#')
  723. read_through_eol(file);
  724. else
  725. {
  726. /* The following are fields read from a record of the file */
  727. char file_map[MAX_TOKEN + 1];
  728. char file_pguser[MAX_TOKEN + 1];
  729. char file_iuser[MAX_TOKEN + 1];
  731. parse_map_record(file, file_map, file_pguser, file_iuser);
  732. if (strcmp(file_map, usermap_name) == 0 &&
  733. strcmp(file_pguser, pguser) == 0 &&
  734. strcmp(file_iuser, ident_username) == 0)
  735. match = true;
  736. }
  737. }
  738. }
  739. *checks_out_p = match;
  740. }
  744. static void
  745. verify_against_usermap(const char *pguser,
  746.    const char *ident_username,
  747.    const char *usermap_name,
  748.    bool *checks_out_p)
  749. {
  750. /*--------------------------------------------------------------------------
  751.   See if the user with ident username "ident_username" is allowed to act
  752.   as Postgres user "pguser" according to usermap "usermap_name".   Look
  753.   it up in the usermap file.
  755.   Special case: For usermap "sameuser", don't look in the usermap
  756.   file.  That's an implied map where "pguser" must be identical to
  757.   "ident_username" in order to be authorized.
  759.   Iff authorized, return *checks_out_p == true.
  761. --------------------------------------------------------------------------*/
  763. if (usermap_name[0] == '')
  764. {
  765. *checks_out_p = false;
  766. snprintf(PQerrormsg, ERROR_MSG_LENGTH,
  767.    "verify_against_usermap: hba configuration file does not "
  768.    "have the usermap field filled in in the entry that pertains "
  769.   "to this connection.  That field is essential for Ident-based "
  770.  "authentication.n");
  771. fputs(PQerrormsg, stderr);
  772. pqdebug("%s", PQerrormsg);
  773. }
  774. else if (strcmp(usermap_name, "sameuser") == 0)
  775. {
  776. if (strcmp(ident_username, pguser) == 0)
  777. *checks_out_p = true;
  778. else
  779. *checks_out_p = false;
  780. }
  781. else
  782. {
  783. FILE    *file; /* The map file we have to read */
  784. char    *map_file; /* The name of the map file we have to
  785.  * read */
  786. int bufsize;
  788. /* put together the full pathname to the map file */
  789. bufsize = (strlen(DataDir) + strlen(USERMAP_FILE) + 2) * sizeof(char);
  790. map_file = (char *) palloc(bufsize);
  791. snprintf(map_file, bufsize, "%s/%s", DataDir, USERMAP_FILE);
  793. #ifndef __CYGWIN32__
  794. file = AllocateFile(map_file, "r");
  795. #else
  796. file = AllocateFile(map_file, "rb");
  797. #endif
  798. if (file == NULL)
  799. {
  800. /* The open of the map file failed.  */
  802. *checks_out_p = false;
  804. snprintf(PQerrormsg, ERROR_MSG_LENGTH,
  805.   "verify_against_usermap: usermap file for Ident-based "
  806.  "authentication "
  807. "does not exist or permissions are not setup correctly! "
  808.  "Unable to open file "%s".n",
  809.  map_file);
  810. fputs(PQerrormsg, stderr);
  811. pqdebug("%s", PQerrormsg);
  812. }
  813. else
  814. {
  815. verify_against_open_usermap(file,
  816. pguser, ident_username, usermap_name,
  817. checks_out_p);
  818. FreeFile(file);
  819. }
  820. pfree(map_file);
  823. }
  824. }
  828. int
  829. authident(struct sockaddr_in * raddr, struct sockaddr_in * laddr,
  830.   const char *postgres_username,
  831.   const char *auth_arg)
  832. {
  833. /*---------------------------------------------------------------------------
  834.   Talk to the ident server on the remote host and find out who owns the
  835.   connection described by "port".  Then look in the usermap file under
  836.   the usermap *auth_arg and see if that user is equivalent to
  837.   Postgres user *user.
  839.   Return STATUS_OK if yes.
  840. ---------------------------------------------------------------------------*/
  841. bool checks_out;
  842. bool ident_failed;
  844. /* We were unable to get ident to give us a username */
  845. char ident_username[IDENT_USERNAME_MAX + 1];
  847. /* The username returned by ident */
  849. ident(raddr->sin_addr, laddr->sin_addr,
  850.   raddr->sin_port, laddr->sin_port,
  851.   &ident_failed, ident_username);
  853. if (ident_failed)
  854. return STATUS_ERROR;
  856. verify_against_usermap(postgres_username, ident_username, auth_arg,
  857.    &checks_out);
  859. return checks_out ? STATUS_OK : STATUS_ERROR;
  860. }
  863. #ifdef CYR_RECODE
  864. #define CHARSET_FILE "charset.conf"
  865. #define MAX_CHARSETS   10
  866. #define KEY_HOST    1
  867. #define KEY_BASE    2
  868. #define KEY_TABLE    3
  870. struct CharsetItem
  871. {
  872. char Orig[MAX_TOKEN];
  873. char Dest[MAX_TOKEN];
  874. char Table[MAX_TOKEN];
  875. };
  877. int
  878. InRange(char *buf, int host)
  879. {
  880. int valid,
  881. i,
  882. FromAddr,
  883. ToAddr,
  884. tmp;
  885. struct in_addr file_ip_addr;
  886. char    *p;
  887. unsigned int one = 0x80000000,
  888. NetMask = 0;
  889. unsigned char mask;
  891. p = strchr(buf, '/');
  892. if (p)
  893. {
  894. *p++ = '';
  895. valid = inet_aton(buf, &file_ip_addr);
  896. if (valid)
  897. {
  898. mask = strtoul(p, 0, 0);
  899. FromAddr = ntohl(file_ip_addr.s_addr);
  900. ToAddr = ntohl(file_ip_addr.s_addr);
  901. for (i = 0; i < mask; i++)
  902. {
  903. NetMask |= one;
  904. one >>= 1;
  905. }
  906. FromAddr &= NetMask;
  907. ToAddr = ToAddr | ~NetMask;
  908. tmp = ntohl(host);
  909. return ((unsigned) tmp >= (unsigned) FromAddr &&
  910. (unsigned) tmp <= (unsigned) ToAddr);
  911. }
  912. }
  913. else
  914. {
  915. p = strchr(buf, '-');
  916. if (p)
  917. {
  918. *p++ = '';
  919. valid = inet_aton(buf, &file_ip_addr);
  920. if (valid)
  921. {
  922. FromAddr = ntohl(file_ip_addr.s_addr);
  923. valid = inet_aton(p, &file_ip_addr);
  924. if (valid)
  925. {
  926. ToAddr = ntohl(file_ip_addr.s_addr);
  927. tmp = ntohl(host);
  928. return ((unsigned) tmp >= (unsigned) FromAddr &&
  929. (unsigned) tmp <= (unsigned) ToAddr);
  930. }
  931. }
  932. }
  933. else
  934. {
  935. valid = inet_aton(buf, &file_ip_addr);
  936. if (valid)
  937. {
  938. FromAddr = file_ip_addr.s_addr;
  939. return (unsigned) FromAddr == (unsigned) host;
  940. }
  941. }
  942. }
  943. return false;
  944. }
  946. void
  947. GetCharSetByHost(char *TableName, int host, const char *DataDir)
  948. {
  949. FILE    *file;
  950. char buf[MAX_TOKEN],
  951. BaseCharset[MAX_TOKEN],
  952. OrigCharset[MAX_TOKEN],
  953. DestCharset[MAX_TOKEN],
  954. HostCharset[MAX_TOKEN],
  955. c,
  956. eof = false,
  957.    *map_file;
  958. int key = 0,
  959. ChIndex = 0,
  960. i,
  961. bufsize;
  963. struct CharsetItem *ChArray[MAX_CHARSETS];
  965. *TableName = '';
  966. bufsize = (strlen(DataDir) + strlen(CHARSET_FILE) + 2) * sizeof(char);
  967. map_file = (char *) palloc(bufsize);
  968. snprintf(map_file, bufsize, "%s/%s", DataDir, CHARSET_FILE);
  969. #ifndef __CYGWIN32__
  970. file = AllocateFile(map_file, "r");
  971. #else
  972. file = AllocateFile(map_file, "rb");
  973. #endif
  974. if (file == NULL)
  975. return;
  976. while (!eof)
  977. {
  978. c = getc(file);
  979. ungetc(c, file);
  980. if (c == EOF)
  981. eof = true;
  982. else
  983. {
  984. if (c == '#')
  985. read_through_eol(file);
  986. else
  987. {
  988. /* Read the key */
  989. next_token(file, buf, sizeof(buf));
  990. if (buf[0] != '')
  991. {
  992. if (strcasecmp(buf, "HostCharset") == 0)
  993. key = KEY_HOST;
  994. if (strcasecmp(buf, "BaseCharset") == 0)
  995. key = KEY_BASE;
  996. if (strcasecmp(buf, "RecodeTable") == 0)
  997. key = KEY_TABLE;
  998. switch (key)
  999. {
  1000. case KEY_HOST:
  1001. /* Read the host */
  1002. next_token(file, buf, sizeof(buf));
  1003. if (buf[0] != '')
  1004. {
  1005. if (InRange(buf, host))
  1006. {
  1007. /* Read the charset */
  1008. next_token(file, buf, sizeof(buf));
  1009. if (buf[0] != '')
  1010. strcpy(HostCharset, buf);
  1011. }
  1012. }
  1013. break;
  1014. case KEY_BASE:
  1015. /* Read the base charset */
  1016. next_token(file, buf, sizeof(buf));
  1017. if (buf[0] != '')
  1018. strcpy(BaseCharset, buf);
  1019. break;
  1020. case KEY_TABLE:
  1021. /* Read the original charset */
  1022. next_token(file, buf, sizeof(buf));
  1023. if (buf[0] != '')
  1024. {
  1025. strcpy(OrigCharset, buf);
  1026. /* Read the destination charset */
  1027. next_token(file, buf, sizeof(buf));
  1028. if (buf[0] != '')
  1029. {
  1030. strcpy(DestCharset, buf);
  1031. /* Read the table filename */
  1032. next_token(file, buf, sizeof(buf));
  1033. if (buf[0] != '')
  1034. {
  1035. ChArray[ChIndex] =
  1036. (struct CharsetItem *) palloc(sizeof(struct CharsetItem));
  1037. strcpy(ChArray[ChIndex]->Orig, OrigCharset);
  1038. strcpy(ChArray[ChIndex]->Dest, DestCharset);
  1039. strcpy(ChArray[ChIndex]->Table, buf);
  1040. ChIndex++;
  1041. }
  1042. }
  1043. }
  1044. break;
  1045. }
  1046. read_through_eol(file);
  1047. }
  1048. }
  1049. }
  1050. }
  1051. FreeFile(file);
  1052. pfree(map_file);
  1054. for (i = 0; i < ChIndex; i++)
  1055. {
  1056. if (!strcasecmp(BaseCharset, ChArray[i]->Orig) &&
  1057. !strcasecmp(HostCharset, ChArray[i]->Dest))
  1058. strncpy(TableName, ChArray[i]->Table, 79);
  1059. pfree((struct CharsetItem *) ChArray[i]);
  1060. }
  1061. }
  1063. #endif
  1065. int
  1066. hba_getauthmethod(SockAddr *raddr, char *user, char *database,
  1067.   char *auth_arg, UserAuth *auth_method)
  1068. {
  1069. /*---------------------------------------------------------------------------
  1070.   Determine what authentication method should be used when accessing database
  1071.   "database" from frontend "raddr", user "user".  Return the method,
  1072.   an optional argument, and STATUS_OK.
  1073.   Note that STATUS_ERROR indicates a problem with the hba config file.
  1074.   If the file is OK but does not contain any entry matching the request,
  1075.   we return STATUS_OK and method = uaReject.
  1076. ----------------------------------------------------------------------------*/
  1077. bool hba_ok = false;
  1079. find_hba_entry(raddr, user, database, &hba_ok, auth_method, auth_arg);
  1081. return hba_ok ? STATUS_OK : STATUS_ERROR;
  1082. }