Changeset 8358

Show
Ignore:
Timestamp:
06/04/10 15:26:25 (3 years ago)
Author:
nlmills
Message:

added utility function to refresh credentials for long operations

Location:
branches/cu-security-branch
Files:
6 modified

Legend:

Unmodified
Added
Removed
  • branches/cu-security-branch/include/pvfs2-util.h

    r8354 r8358  
    4747int PVFS_util_gen_credential(const char *user, unsigned int timeout, 
    4848    const char *keypath, PVFS_credential *cred); 
     49int PVFS_util_refresh_credential(PVFS_credential *cred); 
    4950 
    5051int PVFS_util_copy_sys_attr( 
  • branches/cu-security-branch/src/apps/admin/pvfs2-cp.c

    r8354 r8358  
    149149    resolve_filename(&dest, user_opts->destfile); 
    150150 
    151     /* nlmills: TODO: find a better way to handle timeouts */ 
    152     ret = PVFS_util_gen_credential(NULL, 5*60*60, NULL, &credentials); 
     151    ret = PVFS_util_gen_credential_defaults(&credentials);     
    153152    if (ret < 0) 
    154153    { 
     
    344343            return (ret); 
    345344        } 
     345        PVFS_util_refresh_credential(credentials); 
    346346        ret = PVFS_sys_read(src->u.pvfs2.ref, file_req, offset, 
    347347                buffer, mem_req, credentials, &resp_io, hints); 
     
    376376            return(ret); 
    377377        } 
     378        PVFS_util_refresh_credential(credentials); 
    378379        ret = PVFS_sys_write(dest->u.pvfs2.ref, file_req, offset, 
    379380                buffer, mem_req, credentials, &resp_io, hints); 
  • branches/cu-security-branch/src/apps/admin/pvfs2-fs-dump.c

    r8351 r8358  
    139139    } 
    140140 
    141     /* nlmills: TODO: find a better way to handle credential timeouts */ 
    142     ret = PVFS_util_gen_credential(NULL, 5*60*60, NULL, &creds); 
     141    ret = PVFS_util_gen_credential_defaults(&creds); 
    143142    if (ret < 0) 
    144143    { 
    145         PVFS_perror("PVFS_util_gen_credential", ret); 
     144        PVFS_perror("PVFS_util_gen_credential_defaults", ret); 
    146145        return(-1); 
    147146    } 
     
    256255    struct PVFS_mgmt_server_stat *stat_array; 
    257256    struct PVFS_mgmt_setparam_value param_value; 
     257 
     258    PVFS_util_refresh_credential(creds); 
    258259 
    259260    /* find out how many handles are in use on each */ 
     
    359360    do 
    360361    { 
    361         ret = PVFS_mgmt_iterate_handles_list(cur_fs, 
     362        PVFS_util_refresh_credential(creds); 
     363        ret = PVFS_mgmt_iterate_handles_list(cur_fs, 
    362364                                             creds, 
    363365                                             handle_matrix, 
     
    454456    PVFS_object_ref pref; 
    455457 
     458    PVFS_util_refresh_credential(creds); 
     459 
    456460    PVFS_sys_lookup(cur_fs, "/", creds, 
    457461                    &lookup_resp, PVFS2_LOOKUP_LINK_NO_FOLLOW, NULL); 
     
    506510    token = 0; 
    507511    do { 
     512        PVFS_util_refresh_credential(creds); 
     513         
    508514        memset(&readdir_resp, 0, sizeof(PVFS_sysresp_readdir)); 
    509515        ret = PVFS_sys_readdir(pref, 
     
    518524            char *cur_file; 
    519525            PVFS_handle cur_handle; 
     526 
     527            PVFS_util_refresh_credential(creds); 
    520528 
    521529            cur_handle = readdir_resp.dirent_array[i].handle; 
     
    600608    PVFS_handle *df_handles; 
    601609 
     610    PVFS_util_refresh_credential(creds); 
     611 
    602612    df_handles = (PVFS_handle *) malloc(df_count * sizeof(PVFS_handle)); 
    603613    if (df_handles == NULL) 
     
    654664        PVFS_object_ref entry_ref; 
    655665        char* fmt_string; 
     666 
     667        PVFS_util_refresh_credential(creds); 
    656668 
    657669        entry_ref.handle = handle; 
  • branches/cu-security-branch/src/apps/admin/pvfs2-fsck.c

    r8351 r8358  
    8282    } 
    8383 
    84     /* nlmills: TODO: find a better way to handle credential timeouts */ 
    85     ret = PVFS_util_gen_credential(NULL, 5*60*60, NULL, &creds); 
     84    ret = PVFS_util_gen_credential_defaults(&creds); 
    8685    if (ret < 0) 
    8786    { 
    88         PVFS_perror("PVFS_util_gen_credential", ret); 
     87        PVFS_perror("PVFS_util_gen_credential_defaults", ret); 
    8988        return -1; 
    9089    } 
     
    189188    handlelist_finalize(&hl_all); 
    190189 
     190    PVFS_util_refresh_credential(&creds); 
     191 
    191192    param_value.type = PVFS_MGMT_PARAM_TYPE_UINT64; 
    192193    param_value.u.value = PVFS_SERVER_NORMAL_MODE; 
     
    225226 
    226227 exit_now: 
     228    PVFS_util_refresh_credential(&creds); 
     229 
    227230    if (in_admin_mode) { 
    228231 
     
    264267    struct PVFS_mgmt_setparam_value param_value; 
    265268 
     269    PVFS_util_refresh_credential(creds); 
     270 
    266271    /* find out how many handles are in use on each */ 
    267272    stat_array = (struct PVFS_mgmt_server_stat *) 
     
    368373    while (more_flag) 
    369374    { 
     375        PVFS_util_refresh_credential(creds); 
     376 
    370377        ret = PVFS_mgmt_iterate_handles_list(cur_fs, 
    371378                                             creds, 
     
    452459    while (more_flag) 
    453460    { 
     461        PVFS_util_refresh_credential(creds); 
     462 
    454463        ret = PVFS_mgmt_iterate_handles_list(cur_fs, 
    455464                                             creds, 
     
    534543    PVFS_sysresp_getattr getattr_resp; 
    535544    PVFS_object_ref pref; 
     545 
     546    PVFS_util_refresh_credential(creds); 
    536547 
    537548    ret = PVFS_sys_lookup(cur_fs, 
     
    889900        PVFS_sysresp_getattr getattr_resp; 
    890901 
     902        PVFS_util_refresh_credential(creds); 
     903 
    891904        handle_ref.handle = handle; 
    892905        handle_ref.fs_id  = cur_fs; 
     
    969982        PVFS_object_ref handle_ref; 
    970983        PVFS_sysresp_getattr getattr_resp; 
     984 
     985        PVFS_util_refresh_credential(creds); 
    971986 
    972987        handle_ref.handle = handle; 
     
    10801095        PVFS_object_ref handle_ref; 
    10811096        PVFS_sysresp_getattr getattr_resp; 
     1097 
     1098        PVFS_util_refresh_credential(creds); 
    10821099 
    10831100        handle_ref.handle = handle; 
  • branches/cu-security-branch/src/apps/admin/pvfs2-perf-mon-example.c

    r8351 r8358  
    7979    } 
    8080 
    81     /* nlmills: TODO: find a better way to handle credential timeouts */ 
    8281    ret = PVFS_util_gen_credential(NULL, 1*60*60, NULL, &creds); 
    8382    if (ret < 0) 
     
    155154    while (1) 
    156155    { 
     156        PVFS_util_refresh_credential(&creds); 
    157157        ret = PVFS_mgmt_perf_mon_list(cur_fs, 
    158158                                      &creds, 
  • branches/cu-security-branch/src/common/misc/pvfs2-util.c

    r8354 r8358  
    269269    close(filedes[0]); 
    270270    sigaction(SIGCLD, &oldsa, NULL); 
     271 
     272    return ret; 
     273} 
     274 
     275int PVFS_util_refresh_credential(PVFS_credential *cred) 
     276{ 
     277    int ret; 
     278 
     279    /* =if the credential is valid for at least a minute */ 
     280    if (PINT_util_get_current_time() <= cred->timeout - 60) 
     281    { 
     282        ret = 0; 
     283    } 
     284    else 
     285    { 
     286        PINT_cleanup_credential(cred); 
     287        ret = PVFS_util_gen_credential_defaults(cred); 
     288    } 
    271289 
    272290    return ret;