home *** CD-ROM | disk | FTP | other *** search
/ ftp.parl.clemson.edu / 2015-02-07.ftp.parl.clemson.edu.tar / ftp.parl.clemson.edu / pub / pvfs2 / orangefs-2.8.3-20110323.tar.gz / orangefs-2.8.3-20110323.tar / orangefs / src / server / prelude.sm < prev    next >
Text File  |  2010-04-30  |  23KB  |  707 lines
  1. /* 
  2.  * (C) 2001 Clemson University and The University of Chicago 
  3.  *
  4.  * See COPYING in top-level directory.
  5.  */
  6.  
  7. #include <string.h>
  8. #include <assert.h>
  9.  
  10. #include "server-config.h"
  11. #include "pvfs2-server.h"
  12. #include "pvfs2-attr.h"
  13. #include "src/server/request-scheduler/request-scheduler.h"
  14. #include "trove.h"
  15. #include "pint-util.h"
  16. #include "pvfs2-internal.h"
  17. #include "pint-perf-counter.h"
  18.  
  19. /* prelude state machine:
  20.  * This is a nested state machine that performs initial setup 
  21.  * steps that are common to many server operations.
  22.  * - post the request to the request scheduler
  23.  * - check permissions
  24.  */
  25. enum {
  26.     PRELUDE_RUN_ACL_CHECKS = 1,
  27. };
  28.  
  29. %%
  30.  
  31. nested machine pvfs2_prelude_work_sm
  32. {
  33.     state req_sched
  34.     {
  35.         run prelude_req_sched;
  36.         success => getattr_if_needed;
  37.         default => return;
  38.     }
  39.  
  40.     state getattr_if_needed
  41.     {
  42.         run prelude_getattr_if_needed;
  43.         default => perm_check;
  44.     }
  45.  
  46.     state perm_check
  47.     {
  48.         run prelude_perm_check;
  49.         PRELUDE_RUN_ACL_CHECKS => check_acls_if_needed;
  50.         default => return;
  51.     }
  52.  
  53.     state check_acls_if_needed
  54.     {
  55.         run prelude_check_acls_if_needed;
  56.         default => check_acls;
  57.     }
  58.  
  59.     state check_acls
  60.     {
  61.         run prelude_check_acls;
  62.         default => return;
  63.     }
  64. }
  65.  
  66. nested machine pvfs2_prelude_sm
  67. {
  68.     state setup
  69.     {
  70.         run prelude_setup;
  71.         default => prelude_work;
  72.     }
  73.  
  74.     state prelude_work
  75.     {
  76.         jump pvfs2_prelude_work_sm;
  77.         default => return;
  78.     }
  79. }
  80.  
  81. %%
  82.  
  83. static PINT_sm_action prelude_setup(
  84.         struct PINT_smcb *smcb, job_status_s *js_p)
  85. {
  86.  
  87.     gossip_debug(GOSSIP_MIRROR_DEBUG,"Executing pvfs2_prelude_sm:prelude_setup...\n");
  88.     gossip_debug(GOSSIP_MIRROR_DEBUG,"\tbase frame:%d\tframe count:%d\n"
  89.                                     ,smcb->base_frame,smcb->frame_count);
  90.     int ret;
  91.     struct PINT_server_op *s_op = PINT_sm_frame(smcb, PINT_FRAME_CURRENT);
  92.  
  93.     ret = PINT_server_req_get_object_ref(
  94.         s_op->req, &s_op->target_fs_id, &s_op->target_handle);
  95.     s_op->access_type = PINT_server_req_get_access_type(s_op->req);
  96.     s_op->sched_policy = PINT_server_req_get_sched_policy(s_op->req);
  97.  
  98.     return SM_ACTION_COMPLETE;
  99. }
  100.  
  101. /* prelude_req_sched()
  102.  *
  103.  * posts a request scheduler job
  104.  */
  105. static PINT_sm_action prelude_req_sched(
  106.         struct PINT_smcb *smcb, job_status_s *js_p)
  107. {
  108.     struct PINT_server_op *s_op = PINT_sm_frame(smcb, PINT_FRAME_CURRENT);
  109.     int ret = -PVFS_EINVAL;
  110.  
  111.     if (s_op->prelude_mask & PRELUDE_SCHEDULER_DONE) {
  112.         gossip_debug(GOSSIP_SERVER_DEBUG,
  113.                  "(%p) %s (prelude sm) state: req_sched already done... skipping.\n", s_op,
  114.                  PINT_map_server_op_to_string(s_op->req->op));
  115.         js_p->error_code = 0;
  116.         return SM_ACTION_COMPLETE;
  117.     }   
  118.  
  119.     gossip_debug(GOSSIP_MIRROR_DEBUG,"Executing pvfs2_prelude_work_sm:prelude_req_sched\n");
  120.     gossip_debug(GOSSIP_MIRROR_DEBUG,"\tbase_frame:%d\tframe_count:%d\n"
  121.                                     ,smcb->base_frame,smcb->frame_count);
  122.     gossip_debug(GOSSIP_SERVER_DEBUG,
  123.         "(%p) %s (prelude sm) state: req_sched\n", s_op,
  124.         PINT_map_server_op_to_string(s_op->req->op));
  125.  
  126.     PINT_ACCESS_DEBUG(s_op, GOSSIP_ACCESS_DETAIL_DEBUG, "request\n");
  127.  
  128.     ret = job_req_sched_post(s_op->op, s_op->target_fs_id, s_op->target_handle,
  129.                              s_op->access_type, s_op->sched_policy,
  130.                              smcb, 0, js_p,
  131.                              &(s_op->scheduled_id), server_job_context);
  132.  
  133.     PINT_perf_count(PINT_server_pc, PINT_PERF_REQSCHED, 1, PINT_PERF_ADD);
  134.     return ret;
  135. }
  136.  
  137. /* prelude_getattr_if_needed()
  138.  *
  139.  * reads basic attributes of target object, if there is a particular
  140.  * target object for the operation
  141.  */
  142. static PINT_sm_action prelude_getattr_if_needed(
  143.         struct PINT_smcb *smcb, job_status_s *js_p)
  144. {
  145.     struct PINT_server_op *s_op = PINT_sm_frame(smcb, PINT_FRAME_CURRENT);
  146.     int ret = -PVFS_EINVAL;
  147.     job_id_t tmp_id;
  148.  
  149.     if (s_op->prelude_mask & PRELUDE_GETATTR_DONE) {
  150.         gossip_debug(GOSSIP_SERVER_DEBUG,
  151.                  "(%p) %s (prelude sm) state: getattr already done... skipping.\n", s_op,
  152.                  PINT_map_server_op_to_string(s_op->req->op));
  153.         js_p->error_code = 0;
  154.         return SM_ACTION_COMPLETE;
  155.     }
  156.  
  157.     PINT_ACCESS_DEBUG(s_op, GOSSIP_ACCESS_DETAIL_DEBUG, "start\n");
  158.  
  159.     gossip_debug(GOSSIP_SERVER_DEBUG,
  160.                  "(%p) %s (prelude sm) state: getattr_if_needed\n", s_op,
  161.                  PINT_map_server_op_to_string(s_op->req->op));
  162.  
  163.     /* if the handle is 0, that indicates that the request does not
  164.      * operate on a specific handle, so there is nothing we can do
  165.      * here
  166.      */
  167.     if (s_op->target_handle == PVFS_HANDLE_NULL)
  168.     {
  169.  
  170.         js_p->error_code = 0;
  171.         return SM_ACTION_COMPLETE;
  172.     }
  173.  
  174.     /* all other operations fall to this point and read basic
  175.      * attribute information
  176.      */
  177.     memset(&(s_op->ds_attr), 0, sizeof(PVFS_ds_attributes));
  178.  
  179.     gossip_debug(GOSSIP_SERVER_DEBUG, "About to retrieve attributes "
  180.                  "for handle %llu\n", llu(s_op->target_handle));
  181.  
  182.     ret = job_trove_dspace_getattr(
  183.         s_op->target_fs_id, s_op->target_handle, smcb, &(s_op->ds_attr),
  184.         0, js_p, &tmp_id, server_job_context, s_op->req->hints);
  185.  
  186.     return ret;
  187. }
  188.  
  189. static void get_anon_ids(struct filesystem_configuration_s *fsconfig,
  190.     PVFS_uid *uid, PVFS_gid *gid)
  191. {
  192.     *uid = fsconfig->exp_anon_uid;
  193.     *gid = fsconfig->exp_anon_gid;
  194.     return;
  195. }
  196.  
  197. static int iterate_all_squash_wildcards(struct filesystem_configuration_s *fsconfig,
  198.     PVFS_BMI_addr_t client_addr)
  199. {
  200.     int i;
  201.  
  202.     for (i = 0; i < fsconfig->all_squash_count; i++)
  203.     {
  204.         gossip_debug(GOSSIP_SERVER_DEBUG, "BMI_query_addr_range %lld, %s\n",
  205.             lld(client_addr), fsconfig->all_squash_hosts[i]);
  206.         if (BMI_query_addr_range(client_addr, fsconfig->all_squash_hosts[i],
  207.                 fsconfig->all_squash_netmasks[i]) == 1)
  208.         {
  209.             return 1;
  210.         }
  211.     }
  212.     return 0;
  213. }
  214.  
  215. static int iterate_root_squash_wildcards(struct filesystem_configuration_s *fsconfig,
  216.     PVFS_BMI_addr_t client_addr)
  217. {
  218.     int i;
  219.  
  220.     /* check exceptions first */
  221.     for (i = 0; i < fsconfig->root_squash_exceptions_count; i++)
  222.     {
  223.         gossip_debug(GOSSIP_SERVER_DEBUG, "BMI_query_addr_range %lld, %s, netmask: %i\n",
  224.             lld(client_addr), fsconfig->root_squash_exceptions_hosts[i],
  225.             fsconfig->root_squash_exceptions_netmasks[i]);
  226.         if (BMI_query_addr_range(client_addr, fsconfig->root_squash_exceptions_hosts[i], 
  227.                 fsconfig->root_squash_exceptions_netmasks[i]) == 1)
  228.         {
  229.             /* in the exception list, do not squash */
  230.             return 0;
  231.         }
  232.     }
  233.  
  234.     for (i = 0; i < fsconfig->root_squash_count; i++)
  235.     {
  236.         gossip_debug(GOSSIP_SERVER_DEBUG, "BMI_query_addr_range %lld, %s, netmask: %i\n",
  237.             lld(client_addr), fsconfig->root_squash_hosts[i],
  238.             fsconfig->root_squash_netmasks[i]);
  239.         if (BMI_query_addr_range(client_addr, fsconfig->root_squash_hosts[i], 
  240.                 fsconfig->root_squash_netmasks[i]) == 1)
  241.         {
  242.             return 1;
  243.         }
  244.     }
  245.     return 0;
  246. }
  247.  
  248. /* Translate_ids will return 1 if it did some uid/gid squashing, 0 otherwise */
  249. static int translate_ids(PVFS_fs_id fsid, PVFS_uid uid, PVFS_gid gid, 
  250.     PVFS_uid *translated_uid, PVFS_gid *translated_gid, PVFS_BMI_addr_t client_addr)
  251. {
  252.     int exp_flags = 0;
  253.     struct server_configuration_s *serv_config = NULL;
  254.     struct filesystem_configuration_s * fsconfig = NULL;
  255.  
  256.     serv_config = PINT_get_server_config();
  257.     fsconfig = PINT_config_find_fs_id(serv_config, fsid);
  258.  
  259.     if (fsconfig == NULL)
  260.     {
  261.         return 0;
  262.     }
  263.     exp_flags = fsconfig->exp_flags;
  264.     /* If all squash was set */
  265.     if (exp_flags & TROVE_EXP_ALL_SQUASH)
  266.     {
  267.         if (iterate_all_squash_wildcards(fsconfig, client_addr) == 1)
  268.         {
  269.             get_anon_ids(fsconfig, translated_uid, translated_gid);
  270.             gossip_debug(GOSSIP_SERVER_DEBUG,
  271.                 "Translated ids from <%u:%u> to <%u:%u>\n",
  272.                 uid, gid, *translated_uid, *translated_gid);
  273.             return 1;
  274.         }
  275.     }
  276.     /* if only root squash was set translate uids for root alone*/
  277.     if (exp_flags & TROVE_EXP_ROOT_SQUASH)
  278.     {
  279.         if (uid == 0 || gid == 0)
  280.         {
  281.             if (iterate_root_squash_wildcards(fsconfig, client_addr) == 1)
  282.             {
  283.                 get_anon_ids(fsconfig, translated_uid, translated_gid);
  284.                 gossip_debug(GOSSIP_SERVER_DEBUG,
  285.                     "Translated ids from <%u:%u> to <%u:%u>\n",
  286.                     uid, gid, *translated_uid, *translated_gid);
  287.                 return 1;
  288.             }
  289.         }
  290.     }
  291.     /* no such translation required! */
  292.     *translated_uid = uid;
  293.     *translated_gid = gid;
  294.     return 0;
  295. }
  296.  
  297. static int iterate_ro_wildcards(struct filesystem_configuration_s *fsconfig, PVFS_BMI_addr_t client_addr)
  298. {
  299.     int i;
  300.  
  301.     for (i = 0; i < fsconfig->ro_count; i++)
  302.     {
  303.         gossip_debug(GOSSIP_SERVER_DEBUG, "BMI_query_addr_range %lld, %s\n",
  304.             lld(client_addr), fsconfig->ro_hosts[i]);
  305.         /* Does the client address match the wildcard specification and/or */
  306.         /* the netmask specification?                                      */
  307.         if (BMI_query_addr_range(client_addr, fsconfig->ro_hosts[i],
  308.                 fsconfig->ro_netmasks[i]) == 1)
  309.         {
  310.             return 1;
  311.         }
  312.     }
  313.     return 0;
  314. }
  315.  
  316. /*
  317.  * Return zero if this operation should be allowed.
  318.  */
  319. static int permit_operation(PVFS_fs_id fsid,
  320.                             enum PINT_server_req_access_type access_type,
  321.                             PVFS_BMI_addr_t client_addr)
  322. { 
  323.     int exp_flags = 0; 
  324.     struct server_configuration_s *serv_config = NULL;
  325.     struct filesystem_configuration_s * fsconfig = NULL;
  326.  
  327.     if (access_type == PINT_SERVER_REQ_READONLY)
  328.     {
  329.         return 0;  /* anything that doesn't modify state is okay */
  330.     }
  331.     serv_config = PINT_get_server_config();
  332.     fsconfig = PINT_config_find_fs_id(serv_config, fsid);
  333.  
  334.     if (fsconfig == NULL)
  335.     {
  336.         return 0;
  337.     }
  338.     exp_flags = fsconfig->exp_flags;
  339.  
  340.     /* cheap test to see if ReadOnly was even specified in the exportoptions */
  341.     if (!(exp_flags & TROVE_EXP_READ_ONLY))
  342.     {
  343.         return 0;
  344.     }
  345.     /* Drat. Iterate thru the list of wildcards specified in server_configuration and see
  346.      * the client address matches. if yes, then we deny permission
  347.      */
  348.     if (iterate_ro_wildcards(fsconfig, client_addr) == 1)
  349.     {
  350.         gossip_debug(GOSSIP_SERVER_DEBUG, 
  351.             "Disallowing read-write operation on a read-only exported file-system\n");
  352.         return -EROFS;
  353.     }
  354.     return 0;
  355. }
  356.  
  357. /* prelude_perm_check()
  358.  *
  359.  * this really just marks the spot where we would want to do
  360.  * permission checking, it will be replaced by a couple of states that
  361.  * actually perform this task later
  362.  */
  363. static PINT_sm_action prelude_perm_check(
  364.         struct PINT_smcb *smcb, job_status_s *js_p)
  365. {
  366.     struct PINT_server_op *s_op = PINT_sm_frame(smcb, PINT_FRAME_CURRENT);
  367.     PVFS_object_attr *obj_attr = NULL;
  368.     PVFS_ds_attributes *ds_attr = NULL;
  369.     PVFS_uid translated_uid = s_op->req->credentials.uid;
  370.     PVFS_gid translated_gid = s_op->req->credentials.gid;
  371.     PVFS_fs_id  fsid = PVFS_FS_ID_NULL;
  372.     int squashed_flag = 0;
  373.     int skip_acl_flag = 0;
  374.  
  375.     /* moved gossip server debug output to end of state, so we can report
  376.      * resulting status value.
  377.      */
  378.  
  379.     /*
  380.       first we translate the dspace attributes into a more convenient
  381.       server use-able format.  i.e. a PVFS_object_attr
  382.     */
  383.     ds_attr = &s_op->ds_attr;
  384.     obj_attr = &s_op->attr;
  385.     PVFS_ds_attr_to_object_attr(ds_attr, obj_attr);
  386.     s_op->attr.mask = PVFS_ATTR_COMMON_ALL;
  387.     /* Set the target object attribute pointer.. used later by the acl check */
  388.     s_op->target_object_attr = obj_attr;
  389.  
  390.     if (s_op->prelude_mask & PRELUDE_PERM_CHECK_DONE) {
  391.         gossip_debug(GOSSIP_SERVER_DEBUG,
  392.                  "(%p) %s (prelude sm) state: perm check already done... skipping.\n", s_op,
  393.                  PINT_map_server_op_to_string(s_op->req->op));
  394.         return SM_ACTION_COMPLETE;
  395.     }
  396.  
  397.     if (s_op->target_fs_id != PVFS_FS_ID_NULL)
  398.     {
  399.         /*
  400.          * if we are exporting a volume readonly, disallow any operation that modifies
  401.          * the state of the file-system.
  402.          */
  403.         if (permit_operation(
  404.                 s_op->target_fs_id, s_op->access_type, s_op->addr) < 0)
  405.         {
  406.             js_p->error_code = -PVFS_EROFS;
  407.             return SM_ACTION_COMPLETE;
  408.         }
  409.         else 
  410.         {
  411.             /* Translate the uid and gid's in case we need to do some squashing based on the export and the client address */
  412.             if (translate_ids(fsid, s_op->req->credentials.uid, s_op->req->credentials.gid,
  413.                 &translated_uid, &translated_gid, s_op->addr) == 1)
  414.             {
  415.                 squashed_flag = 1;
  416.                 s_op->req->credentials.uid = translated_uid;
  417.                 s_op->req->credentials.gid = translated_gid;
  418.                 /* in the case of a setattr, translate the ids as well right here */
  419.                 if (s_op->req->op == PVFS_SERV_SETATTR)
  420.                 {
  421.                     s_op->req->u.setattr.attr.owner = translated_uid;
  422.                     s_op->req->u.setattr.attr.group = translated_gid;
  423.                 }
  424.                 else if (s_op->req->op == PVFS_SERV_MKDIR)
  425.                 {
  426.                     s_op->req->u.mkdir.attr.owner = translated_uid;
  427.                     s_op->req->u.mkdir.attr.group = translated_gid;
  428.                 }
  429.             }
  430.        }
  431.     }
  432.  
  433.     /* anything else we treat as a real error */
  434.     if (js_p->error_code)
  435.     {
  436.         js_p->error_code = -PVFS_ERROR_CODE(-js_p->error_code);
  437.         return SM_ACTION_COMPLETE;
  438.     }
  439.  
  440.     gossip_debug(
  441.         GOSSIP_PERMISSIONS_DEBUG, "PVFS operation \"%s\" got "
  442.         "attr mask %d\n\t(attr_uid_valid? %s, attr_owner = "
  443.         "%d, credentials_uid = %d)\n\t(attr_gid_valid? %s, attr_group = "
  444.         "%d, credentials.gid = %d)\n",
  445.         PINT_map_server_op_to_string(s_op->req->op), s_op->attr.mask,
  446.         ((s_op->attr.mask & PVFS_ATTR_COMMON_UID) ? "yes" : "no"),
  447.         s_op->attr.owner, translated_uid,
  448.         ((s_op->attr.mask & PVFS_ATTR_COMMON_GID) ? "yes" : "no"),
  449.         s_op->attr.group, translated_gid);
  450.     
  451.     switch(PINT_server_req_get_perms(s_op->req))
  452.     {
  453.         case PINT_SERVER_CHECK_WRITE:
  454.             js_p->error_code = PINT_check_mode(
  455.                 &(s_op->attr), translated_uid,
  456.                 translated_gid, PINT_ACCESS_WRITABLE);
  457.             break;
  458.         case PINT_SERVER_CHECK_READ:
  459.             js_p->error_code = PINT_check_mode(
  460.                 &(s_op->attr), translated_uid,
  461.                 translated_gid, PINT_ACCESS_READABLE);
  462.             break;
  463.         case PINT_SERVER_CHECK_CRDIRENT:
  464.             /* must also check executable after writable */
  465.             js_p->error_code = PINT_check_mode(
  466.                 &(s_op->attr), translated_uid,
  467.                 translated_gid, PINT_ACCESS_WRITABLE);
  468.             if(js_p->error_code == 0)
  469.             {
  470.                 js_p->error_code = PINT_check_mode(
  471.                     &(s_op->attr), translated_uid,
  472.                     translated_gid, PINT_ACCESS_EXECUTABLE);
  473.             }
  474.             break;
  475.         case PINT_SERVER_CHECK_ATTR:
  476.             /* let datafiles pass through the attr check */
  477.             if (s_op->attr.objtype == PVFS_TYPE_DATAFILE)
  478.             {
  479.                 js_p->error_code = 0;
  480.             }
  481.             /* for now we'll assume extended attribs are treated
  482.              * the same as regular attribs as far as permissions
  483.              */
  484.         else if (s_op->req->op == PVFS_SERV_GETATTR ||
  485.                     s_op->req->op == PVFS_SERV_GETEATTR ||
  486.                     s_op->req->op == PVFS_SERV_LISTEATTR)
  487.         {
  488.         /* getting or listing attributes is always ok -- permission
  489.          * is checked on the parent directory at read time
  490.          */
  491.         js_p->error_code = 0;
  492.         }
  493.             else /* setattr, seteattr, seteattr_list */
  494.             {
  495.                 if(s_op->attr.perms == 0 && s_op->attr.objtype ==
  496.                     PVFS_TYPE_SYMLINK)
  497.                 {
  498.                     /* if the object is of type symlink but has empty perms,
  499.                      * then it must be a newly created symlink object that
  500.                      * does not have its true attributes set yet.  Let this
  501.                      * operation through.
  502.                      */
  503.                     js_p->error_code = 0;
  504.                 }
  505.                 else if(s_op->attr.owner == translated_uid || translated_uid
  506.                     == 0)
  507.                 {
  508.                     /* owner of file and root can always set attributes (see
  509.                      * iozone, which does a setattr as part of truncating a
  510.                      * file with permission mask set to 0
  511.                      */
  512.                     js_p->error_code = 0;
  513.                 }
  514.                 else
  515.                 {
  516.                     /* normal setattr requires write permissions on existing
  517.                      * objects
  518.                      */
  519.                     js_p->error_code = PINT_check_mode(
  520.                         &(s_op->attr), translated_uid,
  521.                         translated_gid, PINT_ACCESS_WRITABLE);
  522.                 }
  523.             }
  524.             break;
  525.         case PINT_SERVER_CHECK_NONE:
  526.             if(squashed_flag &&
  527.                PINT_server_req_get_access_type(s_op->req) == PINT_SERVER_REQ_MODIFY &&
  528.                ((s_op->req->op == PVFS_SERV_IO) ||
  529.                 (s_op->req->op == PVFS_SERV_SMALL_IO) ||
  530.                 (s_op->req->op == PVFS_SERV_TRUNCATE)))
  531.             {
  532.                 /* special case:
  533.                  * If we have been squashed, deny write permission to the
  534.                  * file system.  At the datafile level we don't have enough
  535.                  * attribute information to figure out if the nobody/guest
  536.                  * user has permission to write or not, so we disallow all
  537.                  * writes to be safe.  Not perfect semantics, but better
  538.                  * than being too permissive.
  539.                  */
  540.                 skip_acl_flag = 1;
  541.                 js_p->error_code = -PVFS_EACCES;
  542.             }
  543.             else
  544.             {
  545.                 js_p->error_code = 0;
  546.             }
  547.             break;
  548.         case PINT_SERVER_CHECK_INVALID:
  549.             js_p->error_code = -PVFS_EINVAL;
  550.             break;
  551.     }
  552.  
  553.     gossip_debug(
  554.         GOSSIP_PERMISSIONS_DEBUG, "Final permission check for \"%s\" set "
  555.         "error code to %d\n", PINT_map_server_op_to_string(s_op->req->op),
  556.         js_p->error_code);
  557.  
  558.     gossip_debug(GOSSIP_SERVER_DEBUG, 
  559.         "(%p) %s (prelude sm) state: perm_check (status = %d)\n",
  560.     s_op,
  561.         PINT_map_server_op_to_string(s_op->req->op),
  562.     js_p->error_code);
  563.     /* If regular checks fail, we need to run acl checks */
  564.     if (js_p->error_code == -PVFS_EACCES && !skip_acl_flag)
  565.         js_p->error_code = PRELUDE_RUN_ACL_CHECKS;
  566.     return SM_ACTION_COMPLETE;
  567. }
  568.  
  569.  
  570. static PINT_sm_action prelude_check_acls_if_needed(
  571.     struct PINT_smcb *smcb, job_status_s *js_p)
  572. {
  573.     struct PINT_server_op *s_op = PINT_sm_frame(smcb, PINT_FRAME_CURRENT);
  574.     int ret = -PVFS_EINVAL;
  575.     job_id_t i;
  576.  
  577.     gossip_debug(GOSSIP_SERVER_DEBUG,
  578.                  "(%p) %s (prelude sm) state: prelude_check_acls_if_needed\n", s_op,
  579.                  PINT_map_server_op_to_string(s_op->req->op));
  580.  
  581.     /* If we get here with an invalid fsid and handle, we have to
  582.      * return -PVFS_EACCESS 
  583.      */
  584.     if (s_op->target_fs_id == PVFS_FS_ID_NULL
  585.         || s_op->target_handle == PVFS_HANDLE_NULL)
  586.     {
  587.         js_p->error_code = -PVFS_EACCES;
  588.         return SM_ACTION_COMPLETE;
  589.     }
  590.     js_p->error_code = 0;
  591.  
  592.     memset(&s_op->key, 0, sizeof(PVFS_ds_keyval));
  593.     memset(&s_op->val, 0, sizeof(PVFS_ds_keyval));
  594.     s_op->key.buffer = "system.posix_acl_access";
  595.     s_op->key.buffer_sz = strlen(s_op->key.buffer) + 1;
  596.     s_op->val.buffer = (char *) malloc(PVFS_REQ_LIMIT_VAL_LEN);
  597.     if (!s_op->val.buffer)
  598.     {
  599.         js_p->error_code = -PVFS_ENOMEM;
  600.         return SM_ACTION_COMPLETE;
  601.     }
  602.     s_op->val.buffer_sz = PVFS_REQ_LIMIT_VAL_LEN;
  603.  
  604.     gossip_debug(GOSSIP_PERMISSIONS_DEBUG, "About to retrieve acl keyvals "
  605.                  "for handle %llu\n", llu(s_op->target_handle));
  606.  
  607.     /* Read acl keys */
  608.     ret = job_trove_keyval_read(
  609.         s_op->target_fs_id,
  610.         s_op->target_handle,
  611.         &s_op->key,
  612.         &s_op->val,
  613.         0,
  614.         NULL,
  615.         smcb,
  616.         0,
  617.         js_p,
  618.         &i,
  619.         server_job_context,
  620.         s_op->req->hints);
  621.     return ret;
  622. }
  623.  
  624. static PINT_sm_action prelude_check_acls(
  625.     struct PINT_smcb *smcb, job_status_s *js_p)
  626. {
  627.     struct PINT_server_op *s_op = PINT_sm_frame(smcb, PINT_FRAME_CURRENT);
  628.     PVFS_object_attr *obj_attr = NULL;
  629.     int want = 0;
  630.  
  631.     /* The dspace attr must have been read at this point */
  632.     obj_attr = s_op->target_object_attr;
  633.     assert(obj_attr);
  634.  
  635.     /* if we didn't find the acl attributes, then just treat it as a
  636.      * permission denied case.
  637.      */
  638.     if (js_p->error_code == -TROVE_ENOENT)
  639.     {
  640.         js_p->error_code = -PVFS_EACCES;
  641.         goto cleanup;
  642.     }
  643.  
  644.     /* anything else non-zero we treat as a real error */
  645.     if (js_p->error_code)
  646.     {
  647.         goto cleanup;
  648.     }
  649.     /* make sure that we hit here only for metafiles, dirs and symlink objects */
  650.     if (obj_attr->objtype != PVFS_TYPE_METAFILE
  651.         && obj_attr->objtype != PVFS_TYPE_DIRECTORY
  652.         && obj_attr->objtype != PVFS_TYPE_SYMLINK)
  653.     {
  654.         gossip_err("prelude_check_acls hit invalid object type %d\n",
  655.             obj_attr->objtype);
  656.         js_p->error_code = -PVFS_EINVAL;
  657.         goto cleanup;
  658.     }
  659.     switch (PINT_server_req_get_perms(s_op->req))
  660.     {
  661.         case PINT_SERVER_CHECK_WRITE:
  662.         default:
  663.             want = PVFS2_ACL_WRITE;
  664.             break;
  665.         case PINT_SERVER_CHECK_READ:
  666.             want = PVFS2_ACL_READ;
  667.             break;
  668.         case PINT_SERVER_CHECK_CRDIRENT:
  669.             want = PVFS2_ACL_WRITE | PVFS2_ACL_EXECUTE;
  670.             break;
  671.         case PINT_SERVER_CHECK_NONE:
  672.             want = 0;
  673.             break;
  674.         case PINT_SERVER_CHECK_INVALID:
  675.             js_p->error_code = -PVFS_EINVAL;
  676.             goto cleanup;
  677.     }
  678.     js_p->error_code = PINT_check_acls(s_op->val.buffer,
  679.                         s_op->val.read_sz,
  680.                         obj_attr, 
  681.                         s_op->req->credentials.uid,
  682.                         s_op->req->credentials.gid,
  683.                         want);
  684. cleanup:
  685.     gossip_debug(
  686.         GOSSIP_PERMISSIONS_DEBUG, "Final permission check (after acls) \"%s\" set "
  687.         "error code to %d (want %x)\n",
  688.             PINT_map_server_op_to_string(s_op->req->op),
  689.             js_p->error_code, want);
  690.  
  691.     if (s_op->val.buffer) 
  692.         free(s_op->val.buffer);
  693.     memset(&s_op->key, 0, sizeof(PVFS_ds_keyval));
  694.     memset(&s_op->val, 0, sizeof(PVFS_ds_keyval));
  695.     return SM_ACTION_COMPLETE;
  696. }
  697.  
  698. /*
  699.  * Local variables:
  700.  *  mode: c
  701.  *  c-indent-level: 4
  702.  *  c-basic-offset: 4
  703.  * End:
  704.  *
  705.  * vim: ft=c ts=8 sts=4 sw=4 expandtab
  706.  */
  707.