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

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

数据库系统

开发平台：

Unix_Linux

acl.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * acl.c
  4.  *   Basic access control list data structures manipulation routines.
  5.  *
  6.  * Copyright (c) 1994, Regents of the University of California
  7.  *
  8.  *
  9.  * IDENTIFICATION
  10.  *   $Header: /usr/local/cvsroot/pgsql/src/backend/utils/adt/acl.c,v 1.37.2.1 1999/08/02 05:24:49 scrappy Exp $
  11.  *
  12.  *-------------------------------------------------------------------------
  13.  */
  14. #include <ctype.h>
  15. #include "postgres.h"
  17. #include "catalog/catalog.h"
  18. #include "catalog/pg_shadow.h"
  19. #include "catalog/pg_type.h"
  20. #include "miscadmin.h"
  21. #include "utils/acl.h"
  22. #include "utils/memutils.h"
  23. #include "utils/syscache.h"
  25. static char *getid(char *s, char *n);
  26. static int32 aclitemeq(AclItem *a1, AclItem *a2);
  27. static int32 aclitemgt(AclItem *a1, AclItem *a2);
  28. static char *aclparse(char *s, AclItem *aip, unsigned *modechg);
  30. #define ACL_IDTYPE_GID_KEYWORD "group"
  31. #define ACL_IDTYPE_UID_KEYWORD "user"
  34. /*
  35.  * getid
  36.  * Consumes the first alphanumeric string (identifier) found in string
  37.  * 's', ignoring any leading white space. If it finds a double quote
  38.  * it returns the word inside the quotes.
  39.  *
  40.  * RETURNS:
  41.  * the string position in 's' that points to the next non-space character
  42.  * in 's', after any quotes.  Also:
  43.  * - loads the identifier into 'name'.  (If no identifier is found, 'name'
  44.  *   contains an empty string).
  45.  */
  46. static char *
  47. getid(char *s, char *n)
  48. {
  49. unsigned len;
  50. char    *id;
  51. int in_quotes = 0;
  53. Assert(s && n);
  55. while (isspace(*s))
  56. ++s;
  58. if (*s == '"')
  59. {
  60. in_quotes = 1;
  61. s++;
  62. }
  64. for (id = s, len = 0; isalnum(*s) || *s == '_' || in_quotes; ++len, ++s)
  65. {
  66. if (in_quotes && *s == '"')
  67. {
  68. len--;
  69. in_quotes = 0;
  70. }
  71. }
  72. if (len > sizeof(NameData))
  73. elog(ERROR, "getid: identifier cannot be >%d characters",
  74.  sizeof(NameData));
  75. if (len > 0)
  76. memmove(n, id, len);
  77. n[len] = '';
  78. while (isspace(*s))
  79. ++s;
  80. return s;
  81. }
  83. /*
  84.  * aclparse
  85.  * Consumes and parses an ACL specification of the form:
  86.  * [group|user] [A-Za-z0-9]*[+-=][rwaR]*
  87.  * from string 's', ignoring any leading white space or white space
  88.  * between the optional id type keyword (group|user) and the actual
  89.  * ACL specification.
  90.  *
  91.  * This routine is called by the parser as well as aclitemin(), hence
  92.  * the added generality.
  93.  *
  94.  * RETURNS:
  95.  * the string position in 's' immediately following the ACL
  96.  * specification. Also:
  97.  * - loads the structure pointed to by 'aip' with the appropriate
  98.  *   UID/GID, id type identifier and mode type values.
  99.  * - loads 'modechg' with the mode change flag.
  100.  */
  101. static char *
  102. aclparse(char *s, AclItem *aip, unsigned *modechg)
  103. {
  104. HeapTuple htup;
  105. char name[NAMEDATALEN];
  107. Assert(s && aip && modechg);
  109. #ifdef ACLDEBUG_TRACE
  110. printf("aclparse: input = '%s'n", s);
  111. #endif
  112. aip->ai_idtype = ACL_IDTYPE_UID;
  113. s = getid(s, name);
  114. if (*s != ACL_MODECHG_ADD_CHR &&
  115. *s != ACL_MODECHG_DEL_CHR &&
  116. *s != ACL_MODECHG_EQL_CHR)
  117. {
  118. /* we just read a keyword, not a name */
  119. if (!strcmp(name, ACL_IDTYPE_GID_KEYWORD))
  120. aip->ai_idtype = ACL_IDTYPE_GID;
  121. else if (strcmp(name, ACL_IDTYPE_UID_KEYWORD))
  122. elog(ERROR, "aclparse: bad keyword, must be [group|user]");
  123. s = getid(s, name); /* move s to the name beyond the keyword */
  124. if (name[0] == '')
  125. elog(ERROR, "aclparse: a name must follow the [group|user] keyword");
  126. }
  127. if (name[0] == '')
  128. aip->ai_idtype = ACL_IDTYPE_WORLD;
  130. switch (*s)
  131. {
  132. case ACL_MODECHG_ADD_CHR:
  133. *modechg = ACL_MODECHG_ADD;
  134. break;
  135. case ACL_MODECHG_DEL_CHR:
  136. *modechg = ACL_MODECHG_DEL;
  137. break;
  138. case ACL_MODECHG_EQL_CHR:
  139. *modechg = ACL_MODECHG_EQL;
  140. break;
  141. default:
  142. elog(ERROR, "aclparse: mode change flag must use "%s"",
  143.  ACL_MODECHG_STR);
  144. }
  146. aip->ai_mode = ACL_NO;
  147. while (isalpha(*++s))
  148. {
  149. switch (*s)
  150. {
  151. case ACL_MODE_AP_CHR:
  152. aip->ai_mode |= ACL_AP;
  153. break;
  154. case ACL_MODE_RD_CHR:
  155. aip->ai_mode |= ACL_RD;
  156. break;
  157. case ACL_MODE_WR_CHR:
  158. aip->ai_mode |= ACL_WR;
  159. break;
  160. case ACL_MODE_RU_CHR:
  161. aip->ai_mode |= ACL_RU;
  162. break;
  163. default:
  164. elog(ERROR, "aclparse: mode flags must use "%s"",
  165.  ACL_MODE_STR);
  166. }
  167. }
  169. switch (aip->ai_idtype)
  170. {
  171. case ACL_IDTYPE_UID:
  172. htup = SearchSysCacheTuple(USENAME,
  173.    PointerGetDatum(name),
  174.    0, 0, 0);
  175. if (!HeapTupleIsValid(htup))
  176. elog(ERROR, "aclparse: non-existent user "%s"", name);
  177. aip->ai_id = ((Form_pg_shadow) GETSTRUCT(htup))->usesysid;
  178. break;
  179. case ACL_IDTYPE_GID:
  180. aip->ai_id = get_grosysid(name);
  181. break;
  182. case ACL_IDTYPE_WORLD:
  183. aip->ai_id = ACL_ID_WORLD;
  184. break;
  185. }
  187. #ifdef ACLDEBUG_TRACE
  188. elog(DEBUG, "aclparse: correctly read [%x %d %x], modechg=%x",
  189.  aip->ai_idtype, aip->ai_id, aip->ai_mode, *modechg);
  190. #endif
  191. return s;
  192. }
  194. /*
  195.  * makeacl
  196.  * Allocates storage for a new Acl with 'n' entries.
  197.  *
  198.  * RETURNS:
  199.  * the new Acl
  200.  */
  201. Acl *
  202. makeacl(int n)
  203. {
  204. Acl    *new_acl;
  205. Size size;
  207. if (n < 0)
  208. elog(ERROR, "makeacl: invalid size: %dn", n);
  209. size = ACL_N_SIZE(n);
  210. if (!(new_acl = (Acl *) palloc(size)))
  211. elog(ERROR, "makeacl: palloc failed on %dn", size);
  212. MemSet((char *) new_acl, 0, size);
  213. new_acl->size = size;
  214. new_acl->ndim = 1;
  215. new_acl->flags = 0;
  216. ARR_LBOUND(new_acl)[0] = 0;
  217. ARR_DIMS(new_acl)[0] = n;
  218. return new_acl;
  219. }
  221. /*
  222.  * aclitemin
  223.  * Allocates storage for, and fills in, a new AclItem given a string
  224.  * 's' that contains an ACL specification.  See aclparse for details.
  225.  *
  226.  * RETURNS:
  227.  * the new AclItem
  228.  */
  229. AclItem    *
  230. aclitemin(char *s)
  231. {
  232. unsigned modechg;
  233. AclItem    *aip;
  235. if (!s)
  236. elog(ERROR, "aclitemin: null string");
  238. aip = (AclItem *) palloc(sizeof(AclItem));
  239. if (!aip)
  240. elog(ERROR, "aclitemin: palloc failed");
  241. s = aclparse(s, aip, &modechg);
  242. if (modechg != ACL_MODECHG_EQL)
  243. elog(ERROR, "aclitemin: cannot accept anything but = ACLs");
  244. while (isspace(*s))
  245. ++s;
  246. if (*s)
  247. elog(ERROR, "aclitemin: extra garbage at end of specification");
  248. return aip;
  249. }
  251. /*
  252.  * aclitemout
  253.  * Allocates storage for, and fills in, a new null-delimited string
  254.  * containing a formatted ACL specification.  See aclparse for details.
  255.  *
  256.  * RETURNS:
  257.  * the new string
  258.  */
  259. char *
  260. aclitemout(AclItem *aip)
  261. {
  262. char    *p;
  263. char    *out;
  264. HeapTuple htup;
  265. unsigned i;
  266. static AclItem default_aclitem = {ACL_ID_WORLD,
  267. ACL_IDTYPE_WORLD,
  268. ACL_WORLD_DEFAULT};
  269. extern char *int2out();
  270. char    *tmpname;
  272. if (!aip)
  273. aip = &default_aclitem;
  275. p = out = palloc(strlen("group =arwR ") + 1 + NAMEDATALEN);
  276. if (!out)
  277. elog(ERROR, "aclitemout: palloc failed");
  278. *p = '';
  280. switch (aip->ai_idtype)
  281. {
  282. case ACL_IDTYPE_UID:
  283. htup = SearchSysCacheTuple(USESYSID,
  284.    ObjectIdGetDatum(aip->ai_id),
  285.    0, 0, 0);
  286. if (!HeapTupleIsValid(htup))
  287. {
  288. char    *tmp = int2out(aip->ai_id);
  290. #ifdef NOT_USED
  292. When this elog(NOTICE) goes to the libpq client,
  293. it crashes the
  294. client because the NOTICE protocol is coming right in the middle
  295. of a request for a field value.We skip the NOTICE for now.
  297. elog(NOTICE, "aclitemout: usesysid %d not found",
  298.  aip->ai_id);
  300. #endif
  302. strcat(p, tmp);
  303. pfree(tmp);
  304. }
  305. else
  306. strncat(p, (char *) &((Form_pg_shadow)
  307.   GETSTRUCT(htup))->usename,
  308. sizeof(NameData));
  309. break;
  310. case ACL_IDTYPE_GID:
  311. strcat(p, "group ");
  312. tmpname = get_groname(aip->ai_id);
  313. strncat(p, tmpname, NAMEDATALEN);
  314. break;
  315. case ACL_IDTYPE_WORLD:
  316. break;
  317. default:
  318. elog(ERROR, "aclitemout: bad ai_idtype: %d", aip->ai_idtype);
  319. break;
  320. }
  321. while (*p)
  322. ++p;
  323. *p++ = '=';
  324. for (i = 0; i < N_ACL_MODES; ++i)
  325. if ((aip->ai_mode >> i) & 01)
  326. *p++ = ACL_MODE_STR[i];
  327. *p = '';
  329. return out;
  330. }
  332. /*
  333.  * aclitemeq
  334.  * aclitemgt
  335.  * AclItem equality and greater-than comparison routines.
  336.  * Two AclItems are equal iff they are both NULL or they have the
  337.  * same identifier (and identifier type).
  338.  *
  339.  * RETURNS:
  340.  * a boolean value indicating = or >
  341.  */
  342. static int32
  343. aclitemeq(AclItem *a1, AclItem *a2)
  344. {
  345. if (!a1 && !a2)
  346. return 1;
  347. if (!a1 || !a2)
  348. return 0;
  349. return a1->ai_idtype == a2->ai_idtype && a1->ai_id == a2->ai_id;
  350. }
  352. static int32
  353. aclitemgt(AclItem *a1, AclItem *a2)
  354. {
  355. if (a1 && !a2)
  356. return 1;
  357. if (!a1 || !a2)
  358. return 0;
  359. return ((a1->ai_idtype > a2->ai_idtype) ||
  360. (a1->ai_idtype == a2->ai_idtype && a1->ai_id > a2->ai_id));
  361. }
  363. Acl *
  364. aclownerdefault(char *relname, AclId ownerid)
  365. {
  366. Acl    *acl;
  367. AclItem    *aip;
  369. acl = makeacl(2);
  370. aip = ACL_DAT(acl);
  371. aip[0].ai_idtype = ACL_IDTYPE_WORLD;
  372. aip[0].ai_id = ACL_ID_WORLD;
  373. aip[0].ai_mode = IsSystemRelationName(relname) ? ACL_RD : ACL_WORLD_DEFAULT;
  374. aip[1].ai_idtype = ACL_IDTYPE_UID;
  375. aip[1].ai_id = ownerid;
  376. aip[1].ai_mode = ACL_OWNER_DEFAULT;
  377. return acl;
  378. }
  380. Acl *
  381. acldefault(char *relname)
  382. {
  383. Acl    *acl;
  384. AclItem    *aip;
  386. acl = makeacl(1);
  387. aip = ACL_DAT(acl);
  388. aip[0].ai_idtype = ACL_IDTYPE_WORLD;
  389. aip[0].ai_id = ACL_ID_WORLD;
  390. aip[0].ai_mode = IsSystemRelationName(relname) ? ACL_RD : ACL_WORLD_DEFAULT;
  391. return acl;
  392. }
  394. Acl *
  395. aclinsert3(Acl *old_acl, AclItem *mod_aip, unsigned modechg)
  396. {
  397. Acl    *new_acl;
  398. AclItem    *old_aip,
  399.    *new_aip;
  400. unsigned src,
  401. dst,
  402. num;
  404. if (!old_acl || ACL_NUM(old_acl) < 1)
  405. {
  406. new_acl = makeacl(0);
  407. return new_acl;
  408. }
  409. if (!mod_aip)
  410. {
  411. new_acl = makeacl(ACL_NUM(old_acl));
  412. memmove((char *) new_acl, (char *) old_acl, ACL_SIZE(old_acl));
  413. return new_acl;
  414. }
  416. num = ACL_NUM(old_acl);
  417. old_aip = ACL_DAT(old_acl);
  419. /*
  420.  * Search the ACL for an existing entry for 'id'.  If one exists, just
  421.  * modify the entry in-place (well, in the same position, since we
  422.  * actually return a copy); otherwise, insert the new entry in
  423.  * sort-order.
  424.  */
  425. /* find the first element not less than the element to be inserted */
  426. for (dst = 0; dst < num && aclitemgt(mod_aip, old_aip + dst); ++dst)
  427. ;
  428. if (dst < num && aclitemeq(mod_aip, old_aip + dst))
  429. {
  430. /* modify in-place */
  431. new_acl = makeacl(ACL_NUM(old_acl));
  432. memmove((char *) new_acl, (char *) old_acl, ACL_SIZE(old_acl));
  433. new_aip = ACL_DAT(new_acl);
  434. src = dst;
  435. }
  436. else
  437. {
  438. new_acl = makeacl(num + 1);
  439. new_aip = ACL_DAT(new_acl);
  440. if (dst == 0)
  441. { /* start */
  442. elog(ERROR, "aclinsert3: insertion before world ACL??");
  443. }
  444. else if (dst >= num)
  445. { /* end */
  446. memmove((char *) new_aip,
  447. (char *) old_aip,
  448. num * sizeof(AclItem));
  449. }
  450. else
  451. { /* middle */
  452. memmove((char *) new_aip,
  453. (char *) old_aip,
  454. dst * sizeof(AclItem));
  455. memmove((char *) (new_aip + dst + 1),
  456. (char *) (old_aip + dst),
  457. (num - dst) * sizeof(AclItem));
  458. }
  459. new_aip[dst].ai_id = mod_aip->ai_id;
  460. new_aip[dst].ai_idtype = mod_aip->ai_idtype;
  461. num++; /* set num to the size of new_acl */
  462. src = 0; /* world entry */
  463. }
  464. switch (modechg)
  465. {
  466. case ACL_MODECHG_ADD:
  467. new_aip[dst].ai_mode = old_aip[src].ai_mode | mod_aip->ai_mode;
  468. break;
  469. case ACL_MODECHG_DEL:
  470. new_aip[dst].ai_mode = old_aip[src].ai_mode & ~mod_aip->ai_mode;
  471. break;
  472. case ACL_MODECHG_EQL:
  473. new_aip[dst].ai_mode = mod_aip->ai_mode;
  474. break;
  475. }
  477. /*
  478.  * if the newly added entry has no permissions, delete it from the
  479.  * list.  For example, this helps in removing entries for users who no
  480.  * longer exists...
  481.  */
  482. for (dst = 1; dst < num; dst++)
  483. {
  484. if (new_aip[dst].ai_mode == 0)
  485. {
  486. int i;
  488. for (i = dst + 1; i < num; i++)
  489. {
  490. new_aip[i - 1].ai_id = new_aip[i].ai_id;
  491. new_aip[i - 1].ai_idtype = new_aip[i].ai_idtype;
  492. new_aip[i - 1].ai_mode = new_aip[i].ai_mode;
  493. }
  494. ARR_DIMS(new_acl)[0] = num - 1;
  495. /* Adjust also the array size because it is used for memmove */
  496. ARR_SIZE(new_acl) -= sizeof(AclItem);
  497. break;
  498. }
  499. }
  501. return new_acl;
  502. }
  504. /*
  505.  * aclinsert
  506.  *
  507.  */
  508. Acl *
  509. aclinsert(Acl *old_acl, AclItem *mod_aip)
  510. {
  511. return aclinsert3(old_acl, mod_aip, ACL_MODECHG_EQL);
  512. }
  514. Acl *
  515. aclremove(Acl *old_acl, AclItem *mod_aip)
  516. {
  517. Acl    *new_acl;
  518. AclItem    *old_aip,
  519.    *new_aip;
  520. unsigned dst,
  521. old_num,
  522. new_num;
  524. if (!old_acl || ACL_NUM(old_acl) < 1)
  525. {
  526. new_acl = makeacl(0);
  527. return new_acl;
  528. }
  529. if (!mod_aip)
  530. {
  531. new_acl = makeacl(ACL_NUM(old_acl));
  532. memmove((char *) new_acl, (char *) old_acl, ACL_SIZE(old_acl));
  533. return new_acl;
  534. }
  536. old_num = ACL_NUM(old_acl);
  537. old_aip = ACL_DAT(old_acl);
  539. for (dst = 0; dst < old_num && !aclitemeq(mod_aip, old_aip + dst); ++dst)
  540. ;
  541. if (dst >= old_num)
  542. { /* not found or empty */
  543. new_acl = makeacl(ACL_NUM(old_acl));
  544. memmove((char *) new_acl, (char *) old_acl, ACL_SIZE(old_acl));
  545. }
  546. else
  547. {
  548. new_num = old_num - 1;
  549. new_acl = makeacl(ACL_NUM(old_acl) - 1);
  550. new_aip = ACL_DAT(new_acl);
  551. if (dst == 0)
  552. { /* start */
  553. elog(ERROR, "aclremove: removal of the world ACL??");
  554. }
  555. else if (dst == old_num - 1)
  556. { /* end */
  557. memmove((char *) new_aip,
  558. (char *) old_aip,
  559. new_num * sizeof(AclItem));
  560. }
  561. else
  562. { /* middle */
  563. memmove((char *) new_aip,
  564. (char *) old_aip,
  565. dst * sizeof(AclItem));
  566. memmove((char *) (new_aip + dst),
  567. (char *) (old_aip + dst + 1),
  568. (new_num - dst) * sizeof(AclItem));
  569. }
  570. }
  571. return new_acl;
  572. }
  574. int32
  575. aclcontains(Acl *acl, AclItem *aip)
  576. {
  577. unsigned i,
  578. num;
  579. AclItem    *aidat;
  581. if (!acl || !aip || ((num = ACL_NUM(acl)) < 1))
  582. return 0;
  583. aidat = ACL_DAT(acl);
  584. for (i = 0; i < num; ++i)
  585. if (aclitemeq(aip, aidat + i))
  586. return 1;
  587. return 0;
  588. }
  590. /* parser support routines */
  592. /*
  593.  * aclmakepriv
  594.  *   make a acl privilege string out of an existing privilege string
  595.  * and a new privilege
  596.  *
  597.  * does not add duplicate privileges
  598.  *
  599.  */
  601. char *
  602. aclmakepriv(char *old_privlist, char new_priv)
  603. {
  604. char    *priv;
  605. int i;
  606. int l;
  608. Assert(strlen(old_privlist) < 5);
  609. priv = palloc(5); /* at most "rwaR" */ ;
  611. if (old_privlist == NULL || old_privlist[0] == '')
  612. {
  613. priv[0] = new_priv;
  614. priv[1] = '';
  615. return priv;
  616. }
  618. strcpy(priv, old_privlist);
  620. l = strlen(old_privlist);
  622. if (l == 4)
  623. { /* can't add any more privileges */
  624. return priv;
  625. }
  627. /* check to see if the new privilege is already in the old string */
  628. for (i = 0; i < l; i++)
  629. {
  630. if (priv[i] == new_priv)
  631. break;
  632. }
  633. if (i == l)
  634. { /* we really have a new privilege */
  635. priv[l] = new_priv;
  636. priv[l + 1] = '';
  637. }
  639. return priv;
  640. }
  642. /*
  643.  * aclmakeuser
  644.  *   user_type must be "A"  - all users
  645.  * "G"  - group
  646.  * "U"  - user
  647.  *
  648.  * concatentates the two strings together with a space in between
  649.  *
  650.  * this routine is used in the parser
  651.  *
  652.  */
  654. char *
  655. aclmakeuser(char *user_type, char *user)
  656. {
  657. char    *user_list;
  659. user_list = palloc(strlen(user) + 3);
  660. sprintf(user_list, "%s %s", user_type, user);
  661. return user_list;
  662. }
  665. /*
  666.  * makeAclStmt:
  667.  *   this is a helper routine called by the parser
  668.  * create a ChangeAclStmt
  669.  *   we take in the privilegs, relation_name_list, and grantee
  670.  * as well as a single character '+' or '-' to indicate grant or revoke
  671.  *
  672.  * returns a new ChangeACLStmt*
  673.  *
  674.  * this routines works by creating a old-style changle acl string and
  675.  * then calling aclparse;
  676.  */
  678. ChangeACLStmt *
  679. makeAclStmt(char *privileges, List *rel_list, char *grantee,
  680. char grant_or_revoke)
  681. {
  682. ChangeACLStmt *n = makeNode(ChangeACLStmt);
  683. char str[MAX_PARSE_BUFFER];
  685. /* see comment in pg_type.h */
  686. Assert(ACLITEMSIZE == sizeof(AclItem));
  688. n->aclitem = (AclItem *) palloc(sizeof(AclItem));
  690. /* the grantee string is "G <group_name>", "U  <user_name>", or "ALL" */
  691. if (grantee[0] == 'G') /* group permissions */
  692. {
  693. sprintf(str, "%s %c%s%c%c%s",
  694. ACL_IDTYPE_GID_KEYWORD,
  695. '"', grantee + 2, '"', grant_or_revoke, privileges);
  696. }
  697. else if (grantee[0] == 'U') /* user permission */
  698. {
  699. sprintf(str, "%s %c%s%c%c%s",
  700. ACL_IDTYPE_UID_KEYWORD,
  701. '"', grantee + 2, '"', grant_or_revoke, privileges);
  702. }
  703. else
  704. /* all permission */
  705. {
  706. sprintf(str, "%c%s",
  707. grant_or_revoke, privileges);
  708. }
  709. n->relNames = rel_list;
  710. aclparse(str, n->aclitem, (unsigned *) &n->modechg);
  711. return n;
  712. }