00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013 #include "reSysDataObjOpr.h"
00014 #include "genQuery.h"
00015 #include "getRescQuota.h"
00016 #include "reServerLib.h"
00017 #include "dataObjOpr.h"
00018 #include "resource.h"
00019 #include "physPath.h"
00020
00021
00022
00023 #include "eirods_resource_backport.h"
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066 int
00067 msiSetDefaultResc (msParam_t *xdefaultRescList, msParam_t *xoptionStr, ruleExecInfo_t *rei )
00068 {
00069 char *defaultRescList;
00070 char *optionStr;
00071 rescGrpInfo_t *myRescGrpInfo = NULL;
00072
00073 defaultRescList = (char *) xdefaultRescList->inOutStruct;
00074
00075 optionStr = (char *) xoptionStr->inOutStruct;
00076
00077 RE_TEST_MACRO (" Calling msiSetDefaultResc")
00078
00079
00080 myRescGrpInfo = new rescGrpInfo_t;
00081 myRescGrpInfo->rescInfo = new rescInfo_t;
00082 eirods::error err = eirods::set_default_resource( rei->rsComm, defaultRescList, optionStr, &rei->doinp->condInput, *myRescGrpInfo );
00083 rei->status = err.code();
00084
00085 if (rei->status >= 0) {
00086 rei->rgi = myRescGrpInfo;
00087 } else {
00088 eirods::log( PASS( err ) );
00089 delete myRescGrpInfo;
00090 rei->rgi = NULL;
00091 }
00092 return (rei->status);
00093 }
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128 int
00129 msiSetRescSortScheme (msParam_t *xsortScheme, ruleExecInfo_t *rei ) {
00130 #if 0 // JMC - legacy resource
00131 rescGrpInfo_t *myRescGrpInfo;
00132 char *sortScheme;
00133
00134 sortScheme = (char *) xsortScheme->inOutStruct;
00135
00136 RE_TEST_MACRO (" Calling msiSetRescSortScheme")
00137
00138 rei->status = 0;
00139
00140 if (sortScheme != NULL && strlen (sortScheme) > 0) {
00141 strncat (rei->statusStr, sortScheme, MAX_NAME_LEN);
00142 strncat (rei->statusStr, "%", MAX_NAME_LEN);
00143 }
00144 if (rei->rgi == NULL) {
00145
00146
00147 eirods::error err = eirods::set_default_resource( rei->rsComm, "", "", &rei->doinp->condInput, *myRescGrpInfo );
00148 rei->status = err.code();
00149
00150 if (rei->status >= 0) {
00151 rei->rgi = myRescGrpInfo;
00152 } else {
00153 eirods::log( PASS( false, -1, "msiSetRescSortScheme - failed", err );
00154 return (rei->status);
00155 }
00156 } else {
00157 myRescGrpInfo = rei->rgi;
00158 }
00159 sortResc (rei->rsComm, &myRescGrpInfo, sortScheme);
00160 rei->rgi = myRescGrpInfo;
00161 return(0);
00162 #else
00163 return -1;
00164 #endif // JMC - legacy resource
00165 }
00166
00167
00168
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205 int
00206 msiSetNoDirectRescInp (msParam_t *xrescList, ruleExecInfo_t *rei)
00207 {
00208
00209 keyValPair_t *condInput;
00210 char *rescName;
00211 char *value;
00212 strArray_t strArray;
00213 int status, i;
00214 char *rescList;
00215
00216 rescList = (char *) xrescList->inOutStruct;
00217
00218 RE_TEST_MACRO (" Calling msiSetNoDirectRescInp")
00219
00220 rei->status = 0;
00221
00222 if (rescList == NULL || strcmp (rescList, "null") == 0) {
00223 return (0);
00224 }
00225
00226 if (rei->rsComm->proxyUser.authInfo.authFlag >= LOCAL_PRIV_USER_AUTH) {
00227
00228 return (0);
00229 }
00230
00231 condInput = &rei->doinp->condInput;
00232
00233 if ((rescName = getValByKey (condInput, BACKUP_RESC_NAME_KW)) == NULL &&
00234 (rescName = getValByKey (condInput, DEST_RESC_NAME_KW)) == NULL &&
00235 (rescName = getValByKey (condInput, DEF_RESC_NAME_KW)) == NULL &&
00236 (rescName = getValByKey (condInput, RESC_NAME_KW)) == NULL) {
00237 return (0);
00238 }
00239
00240 memset (&strArray, 0, sizeof (strArray));
00241
00242 status = parseMultiStr (rescList, &strArray);
00243
00244 if (status <= 0)
00245 return (0);
00246
00247 value = strArray.value;
00248 for (i = 0; i < strArray.len; i++) {
00249 if (strcmp (rescName, &value[i * strArray.size]) == 0) {
00250
00251 rei->status = USER_DIRECT_RESC_INPUT_ERR;
00252 free (value);
00253 return (USER_DIRECT_RESC_INPUT_ERR);
00254 }
00255 }
00256 if (value != NULL)
00257 free (value);
00258 return (0);
00259 }
00260
00261
00262
00263
00264
00265
00266
00267
00268
00269
00270
00271
00272
00273
00274
00275
00276
00277
00278
00279
00280
00281
00282
00283
00284
00285
00286
00287
00288
00289
00290
00291
00292
00293
00294
00295
00296
00297 int
00298 msiSetDataObjPreferredResc (msParam_t *xpreferredRescList, ruleExecInfo_t *rei)
00299 {
00300 int writeFlag;
00301 char *value;
00302 strArray_t strArray;
00303 int status, i;
00304 char *preferredRescList;
00305
00306 preferredRescList = (char *) xpreferredRescList->inOutStruct;
00307
00308 RE_TEST_MACRO (" Calling msiSetDataObjPreferredResc")
00309
00310 rei->status = 0;
00311
00312 if (preferredRescList == NULL || strcmp (preferredRescList, "null") == 0) {
00313 return (0);
00314 }
00315
00316 writeFlag = getWriteFlag (rei->doinp->openFlags);
00317
00318 memset (&strArray, 0, sizeof (strArray));
00319
00320 status = parseMultiStr (preferredRescList, &strArray);
00321
00322 if (status <= 0)
00323 return (0);
00324
00325 if (rei->doi == NULL || rei->doi->next == NULL)
00326 return (0);
00327
00328 value = strArray.value;
00329 for (i = 0; i < strArray.len; i++) {
00330 if (requeDataObjInfoByResc (&rei->doi, &value[i * strArray.size],
00331 writeFlag, 1) >= 0) {
00332 rei->status = 1;
00333 return (rei->status);
00334 }
00335 }
00336 return (rei->status);
00337 }
00338
00339
00340
00341
00342
00343
00344
00345
00346
00347
00348
00349
00350
00351
00352
00353
00354
00355
00356
00357
00358
00359
00360
00361
00362
00363
00364
00365
00366
00367
00368
00369
00370 int
00371 msiSetDataObjAvoidResc (msParam_t *xavoidResc, ruleExecInfo_t *rei)
00372 {
00373 int writeFlag;
00374 char *avoidResc;
00375
00376 avoidResc = (char *) xavoidResc->inOutStruct;
00377
00378 RE_TEST_MACRO (" Calling msiSetDataObjAvoidResc")
00379
00380 rei->status = 0;
00381
00382 writeFlag = getWriteFlag (rei->doinp->openFlags);
00383
00384 if (avoidResc != NULL && strcmp (avoidResc, "null") != 0) {
00385 if (requeDataObjInfoByResc (&rei->doi, avoidResc, writeFlag, 0)
00386 >= 0) {
00387 rei->status = 1;
00388 }
00389 }
00390 return (rei->status);
00391 }
00392
00393
00394
00395
00396
00397
00398
00399
00400
00401
00402
00403
00404
00405
00406
00407
00408
00409
00410
00411
00412
00413
00414
00415
00416
00417
00418
00419
00420
00421
00422
00423
00424 int
00425 msiSortDataObj (msParam_t *xsortScheme, ruleExecInfo_t *rei)
00426 {
00427 char *sortScheme;
00428
00429 sortScheme = (char *) xsortScheme->inOutStruct;
00430 RE_TEST_MACRO (" Calling msiSortDataObj")
00431
00432 rei->status = 0;
00433 if (sortScheme != NULL) {
00434 if (strcmp (sortScheme, "random") == 0) {
00435 sortDataObjInfoRandom (&rei->doi);
00436
00437
00438 }
00439 }
00440 return (rei->status);
00441 }
00442
00443
00444
00445
00446
00447
00448
00449
00450
00451
00452
00453
00454
00455
00456
00457
00458
00459
00460
00461
00462
00463
00464
00465
00466
00467
00468
00469
00470
00471
00472
00473
00474 int
00475 msiSysChksumDataObj (ruleExecInfo_t *rei)
00476 {
00477 dataObjInfo_t *dataObjInfoHead;
00478 char *chksumStr = NULL;
00479
00480 RE_TEST_MACRO (" Calling msiSysChksumDataObj")
00481
00482 rei->status = 0;
00483
00484
00485
00486 dataObjInfoHead = rei->doi;
00487
00488 if (dataObjInfoHead == NULL) {
00489 return (0);
00490 }
00491
00492 if (strlen (dataObjInfoHead->chksum) == 0) {
00493
00494 rei->status = dataObjChksumAndReg (rei->rsComm, dataObjInfoHead,
00495 &chksumStr);
00496 if (chksumStr != NULL) {
00497 rstrcpy (dataObjInfoHead->chksum, chksumStr,NAME_LEN);
00498 free (chksumStr);
00499 }
00500 }
00501
00502 return (0);
00503 }
00504
00505
00506
00507
00508
00509
00510
00511
00512
00513
00514
00515
00516
00517
00518
00519
00520
00521
00522
00523
00524
00525
00526
00527
00528
00529
00530
00531
00532
00533
00534
00535
00536
00537
00538
00539
00540 int
00541 msiSetDataTypeFromExt (ruleExecInfo_t *rei)
00542 {
00543 dataObjInfo_t *dataObjInfoHead;
00544 int status;
00545 char logicalCollName[MAX_NAME_LEN];
00546 char logicalFileName[MAX_NAME_LEN]="";
00547 char logicalFileName1[MAX_NAME_LEN]="";
00548 char logicalFileNameExt[MAX_NAME_LEN]="";
00549 genQueryInp_t genQueryInp;
00550 genQueryOut_t *genQueryOut=NULL;
00551 char condStr1[MAX_NAME_LEN];
00552 char condStr2[MAX_NAME_LEN];
00553 modDataObjMeta_t modDataObjMetaInp;
00554 keyValPair_t regParam;
00555
00556 RE_TEST_MACRO (" Calling msiSetDataType")
00557
00558 rei->status = 0;
00559
00560 dataObjInfoHead = rei->doi;
00561
00562 if (dataObjInfoHead == NULL) {
00563 return (0);
00564 }
00565
00566 status = splitPathByKey(dataObjInfoHead->objPath,
00567 logicalCollName, logicalFileName, '/');
00568 if (strlen(logicalFileName)<=0) return(0);
00569
00570 status = splitPathByKey(logicalFileName,
00571 logicalFileName1, logicalFileNameExt, '.');
00572 if (strlen(logicalFileNameExt)<=0) return(0);
00573
00574
00575 memset (&genQueryInp, 0, sizeof (genQueryInp));
00576
00577 addInxIval (&genQueryInp.selectInp, COL_TOKEN_NAME, 1);
00578
00579 snprintf (condStr1, MAX_NAME_LEN, "= 'data_type'");
00580 addInxVal (&genQueryInp.sqlCondInp, COL_TOKEN_NAMESPACE, condStr1);
00581
00582 snprintf (condStr2, MAX_NAME_LEN, "like '%s|.%s|%s'", "%",
00583 logicalFileNameExt,"%");
00584 addInxVal (&genQueryInp.sqlCondInp, COL_TOKEN_VALUE2, condStr2);
00585
00586 genQueryInp.maxRows=1;
00587
00588 status = rsGenQuery (rei->rsComm, &genQueryInp, &genQueryOut);
00589 if (status != 0 || genQueryOut == NULL ) return(0);
00590
00591 rodsLog (LOG_NOTICE,
00592 "query status %d rowCnt=%d",status, genQueryOut->rowCnt);
00593
00594 if (genQueryOut->rowCnt != 1) return(0);
00595
00596 status = svrCloseQueryOut (rei->rsComm, genQueryOut);
00597
00598
00599 memset (®Param, 0, sizeof (regParam));
00600 addKeyVal (®Param, DATA_TYPE_KW, genQueryOut->sqlResult[0].value);
00601
00602 modDataObjMetaInp.dataObjInfo = dataObjInfoHead;
00603 modDataObjMetaInp.regParam = ®Param;
00604
00605 status = rsModDataObjMeta (rei->rsComm, &modDataObjMetaInp);
00606
00607 return (0);
00608 }
00609
00610
00611
00612
00613
00614
00615
00616
00617
00618
00619
00620
00621
00622
00623
00624
00625
00626
00627
00628
00629
00630
00631
00632
00633
00634
00635
00636
00637
00638
00639
00640
00641
00642
00643 int
00644 msiStageDataObj (msParam_t *xcacheResc, ruleExecInfo_t *rei)
00645 {
00646 int status;
00647 char *cacheResc;
00648
00649 cacheResc = (char *) xcacheResc->inOutStruct;
00650
00651 RE_TEST_MACRO (" Calling msiStageDataObj")
00652
00653 rei->status = 0;
00654
00655 if (cacheResc == NULL || strcmp (cacheResc, "null") == 0) {
00656 return (rei->status);
00657 }
00658
00659
00660 if (rei->doinp->oprType == REPLICATE_OPR ||
00661 rei->doinp->oprType == COPY_DEST ||
00662 rei->doinp->oprType == COPY_SRC) {
00663 return (rei->status);
00664 }
00665
00666 if (getValByKey (&rei->doinp->condInput, RESC_NAME_KW) != NULL ||
00667 getValByKey (&rei->doinp->condInput, REPL_NUM_KW) != NULL) {
00668
00669 return (rei->status);
00670 }
00671
00672 status = msiSysReplDataObj (xcacheResc, NULL, rei);
00673
00674 return (status);
00675 }
00676
00677
00678
00679
00680
00681
00682
00683
00684
00685
00686
00687
00688
00689
00690
00691
00692
00693
00694
00695
00696
00697
00698
00699
00700
00701
00702
00703
00704
00705
00706
00707
00708
00709
00710
00711
00712
00713
00714
00715
00716
00717 int
00718 msiSysReplDataObj (msParam_t *xcacheResc, msParam_t *xflag,
00719 ruleExecInfo_t *rei)
00720 {
00721 int writeFlag;
00722 dataObjInfo_t *dataObjInfoHead;
00723 char *cacheResc;
00724 char *flag = NULL;
00725
00726 cacheResc = (char *) xcacheResc->inOutStruct;
00727 if (xflag != NULL && xflag->inOutStruct != NULL) {
00728 flag = (char *) xflag->inOutStruct;
00729 }
00730
00731 RE_TEST_MACRO (" Calling msiSysReplDataObj")
00732
00733 rei->status = 0;
00734
00735 if (cacheResc == NULL || strcmp (cacheResc, "null") == 0 ||
00736 strlen (cacheResc) == 0) {
00737 return (rei->status);
00738 }
00739
00740 dataObjInfoHead = rei->doi;
00741
00742 if (dataObjInfoHead == NULL) {
00743 return (rei->status);
00744 }
00745
00746 writeFlag = getWriteFlag (rei->doinp->openFlags);
00747
00748 if (requeDataObjInfoByResc (&dataObjInfoHead, cacheResc, writeFlag, 1)
00749 >= 0) {
00750
00751 rei->status = 1;
00752 return (rei->status);
00753 }
00754
00755 rei->status = rsReplAndRequeDataObjInfo (rei->rsComm, &dataObjInfoHead,
00756 cacheResc, flag);
00757 if (rei->status >= 0) {
00758 rei->doi = dataObjInfoHead;
00759 }
00760 return (rei->status);
00761 }
00762
00763
00764
00765
00766
00767
00768
00769
00770
00771
00772
00773
00774
00775
00776
00777
00778
00779
00780
00781
00782
00783
00784
00785
00786
00787
00788
00789
00790
00791
00792
00793
00794
00795
00796
00797
00798
00799
00800
00801
00802
00803 int
00804 msiSetNumThreads (msParam_t *xsizePerThrInMbStr, msParam_t *xmaxNumThrStr,
00805 msParam_t *xwindowSizeStr, ruleExecInfo_t *rei)
00806 {
00807 int sizePerThr;
00808 int maxNumThr;
00809 dataObjInp_t *doinp;
00810 int numThr;
00811 char *sizePerThrInMbStr;
00812 char *maxNumThrStr;
00813 char *windowSizeStr;
00814
00815 sizePerThrInMbStr = (char *) xsizePerThrInMbStr->inOutStruct;
00816 maxNumThrStr = (char *) xmaxNumThrStr->inOutStruct;
00817 windowSizeStr = (char *) xwindowSizeStr->inOutStruct;
00818
00819 if (rei->rsComm != NULL) {
00820 if (strcmp (windowSizeStr, "null") == 0 ||
00821 strcmp (windowSizeStr, "default") == 0) {
00822 rei->rsComm->windowSize = 0;
00823 } else {
00824 rei->rsComm->windowSize = atoi (windowSizeStr);
00825 }
00826 }
00827
00828 if (strcmp (sizePerThrInMbStr, "default") == 0) {
00829 sizePerThr = SZ_PER_TRAN_THR;
00830 } else {
00831 sizePerThr = atoi (sizePerThrInMbStr) * (1024*1024);
00832 if (sizePerThr <= 0) {
00833 rodsLog (LOG_ERROR,
00834 "msiSetNumThreads: Bad input sizePerThrInMb %s", sizePerThrInMbStr);
00835 sizePerThr = SZ_PER_TRAN_THR;
00836 }
00837 }
00838
00839 doinp = rei->doinp;
00840 if (doinp == NULL) {
00841 rodsLog (LOG_ERROR,
00842 "msiSetNumThreads: doinp is NULL");
00843 rei->status = DEF_NUM_TRAN_THR;
00844 return DEF_NUM_TRAN_THR;
00845 }
00846
00847 if (strcmp (maxNumThrStr, "default") == 0) {
00848 maxNumThr = DEF_NUM_TRAN_THR;
00849 } else {
00850 maxNumThr = atoi (maxNumThrStr);
00851 if (maxNumThr < 0) {
00852 rodsLog (LOG_ERROR,
00853 "msiSetNumThreads: Bad input maxNumThr %s", maxNumThrStr);
00854 maxNumThr = DEF_NUM_TRAN_THR;
00855 } else if (maxNumThr == 0) {
00856 rei->status = 0;
00857 return rei->status;
00858 } else if (maxNumThr > MAX_NUM_CONFIG_TRAN_THR) {
00859 rodsLog (LOG_ERROR,
00860 "msiSetNumThreads: input maxNumThr %s too large", maxNumThrStr);
00861 maxNumThr = MAX_NUM_CONFIG_TRAN_THR;
00862 }
00863 }
00864
00865
00866 if (doinp->numThreads > 0) {
00867 numThr = doinp->dataSize / TRANS_BUF_SZ + 1;
00868 if (numThr > doinp->numThreads) {
00869 numThr = doinp->numThreads;
00870 }
00871 } else {
00872 numThr = doinp->dataSize / sizePerThr + 1;
00873 }
00874
00875 if (numThr > maxNumThr)
00876 numThr = maxNumThr;
00877
00878 rei->status = numThr;
00879 return (rei->status);
00880
00881 }
00882
00883
00884
00885
00886
00887
00888
00889
00890
00891
00892
00893
00894
00895
00896
00897
00898
00899
00900
00901
00902
00903
00904
00905
00906
00907
00908
00909
00910
00911
00912
00913 int
00914 msiDeleteDisallowed (ruleExecInfo_t *rei)
00915 {
00916 RE_TEST_MACRO (" Calling msiDeleteDisallowed")
00917
00918 rei->status = SYS_DELETE_DISALLOWED;
00919
00920 return (rei->status);
00921 }
00922
00923
00924
00925
00926
00927
00928
00929
00930
00931
00932
00933
00934
00935
00936
00937
00938
00939
00940
00941
00942
00943
00944
00945
00946
00947
00948
00949
00950
00951
00952
00953 int
00954 msiOprDisallowed (ruleExecInfo_t *rei)
00955 {
00956 RE_TEST_MACRO (" Calling msiOprDisallowed")
00957
00958 rei->status = MSI_OPERATION_NOT_ALLOWED;
00959
00960 return (rei->status);
00961 }
00962
00963
00964
00965
00966
00967
00968
00969
00970
00971
00972
00973
00974
00975
00976
00977
00978
00979
00980
00981
00982
00983
00984
00985
00986
00987
00988
00989
00990
00991
00992
00993
00994 int
00995 msiSetMultiReplPerResc (ruleExecInfo_t *rei)
00996 {
00997 rstrcpy (rei->statusStr, MULTI_COPIES_PER_RESC, MAX_NAME_LEN);
00998 return (0);
00999 }
01000
01001
01002
01003
01004
01005
01006
01007
01008
01009
01010
01011
01012
01013
01014
01015
01016
01017
01018
01019
01020
01021
01022
01023
01024
01025
01026
01027
01028
01029
01030
01031
01032
01033 int
01034 msiNoChkFilePathPerm (ruleExecInfo_t *rei)
01035 {
01036 rei->status = NO_CHK_PATH_PERM;
01037 return (NO_CHK_PATH_PERM);
01038 }
01039
01040
01041
01042
01043
01044
01045
01046
01047
01048
01049
01050
01051
01052
01053
01054
01055
01056
01057
01058
01059
01060
01061
01062
01063
01064
01065
01066
01067
01068
01069
01070
01071
01072 int
01073 msiSetChkFilePathPerm (msParam_t *xchkType, ruleExecInfo_t *rei)
01074 {
01075 char *chkType;
01076
01077 chkType = (char *) xchkType->inOutStruct;
01078
01079 if (strcmp (chkType, DO_CHK_PATH_PERM_STR) == 0) {
01080 rei->status = DO_CHK_PATH_PERM;
01081 } else if (strcmp (chkType, NO_CHK_PATH_PERM_STR) == 0) {
01082 rei->status = NO_CHK_PATH_PERM;
01083 } else if (strcmp (chkType, CHK_NON_VAULT_PATH_PERM_STR) == 0) {
01084 rei->status = CHK_NON_VAULT_PATH_PERM;
01085 } else if (strcmp (chkType, DISALLOW_PATH_REG_STR) == 0) {
01086 rei->status = DISALLOW_PATH_REG;
01087 } else {
01088 rodsLog (LOG_ERROR,
01089 "msiNoChkFilePathPerm:invalid check type %s,set to DISALLOW_PATH_REG");
01090 rei->status = DISALLOW_PATH_REG;
01091 }
01092 return (rei->status);
01093 }
01094
01095
01096
01097
01098
01099
01100
01101
01102
01103
01104
01105
01106
01107
01108
01109
01110
01111
01112
01113
01114
01115
01116
01117
01118
01119
01120
01121
01122
01123
01124
01125
01126 int
01127 msiNoTrashCan (ruleExecInfo_t *rei)
01128 {
01129 rei->status = NO_TRASH_CAN;
01130 return (NO_TRASH_CAN);
01131 }
01132
01133
01134
01135
01136
01137
01138
01139
01140
01141
01142
01143
01144
01145
01146
01147
01148
01149
01150
01151
01152
01153
01154
01155
01156
01157
01158
01159
01160
01161
01162
01163
01164
01165
01166
01167 int
01168 msiSetPublicUserOpr (msParam_t *xoprList, ruleExecInfo_t *rei)
01169 {
01170
01171 char *value;
01172 strArray_t strArray;
01173 int status, i;
01174 char *oprList;
01175
01176 oprList = (char *) xoprList->inOutStruct;
01177
01178 RE_TEST_MACRO (" Calling msiSetPublicUserOpr")
01179
01180 rei->status = 0;
01181
01182 if (oprList == NULL || strcmp (oprList, "null") == 0) {
01183 return (0);
01184 }
01185
01186 if (rei->rsComm->clientUser.authInfo.authFlag < LOCAL_PRIV_USER_AUTH) {
01187
01188 return (SYS_NO_API_PRIV);
01189 }
01190
01191 memset (&strArray, 0, sizeof (strArray));
01192
01193 status = parseMultiStr (oprList, &strArray);
01194
01195 if (status <= 0)
01196 return (0);
01197
01198 value = strArray.value;
01199 for (i = 0; i < strArray.len; i++) {
01200 if (strcmp ("read", &value[i * strArray.size]) == 0) {
01201
01202 setApiPerm (DATA_OBJ_OPEN_AN, PUBLIC_USER_AUTH, PUBLIC_USER_AUTH);
01203 setApiPerm (FILE_OPEN_AN, REMOTE_PRIV_USER_AUTH,
01204 PUBLIC_USER_AUTH);
01205 setApiPerm (FILE_READ_AN, REMOTE_PRIV_USER_AUTH,
01206 PUBLIC_USER_AUTH);
01207 setApiPerm (DATA_OBJ_LSEEK_AN, PUBLIC_USER_AUTH,
01208 PUBLIC_USER_AUTH);
01209 setApiPerm (FILE_LSEEK_AN, REMOTE_PRIV_USER_AUTH,
01210 PUBLIC_USER_AUTH);
01211 setApiPerm (DATA_OBJ_CLOSE_AN, PUBLIC_USER_AUTH,
01212 PUBLIC_USER_AUTH);
01213 setApiPerm (FILE_CLOSE_AN, REMOTE_PRIV_USER_AUTH,
01214 PUBLIC_USER_AUTH);
01215 setApiPerm (OBJ_STAT_AN, PUBLIC_USER_AUTH,
01216 PUBLIC_USER_AUTH);
01217 setApiPerm (DATA_OBJ_GET_AN, PUBLIC_USER_AUTH, PUBLIC_USER_AUTH);
01218 setApiPerm (DATA_GET_AN, REMOTE_PRIV_USER_AUTH, PUBLIC_USER_AUTH);
01219 } else if (strcmp ("query", &value[i * strArray.size]) == 0) {
01220 setApiPerm (GEN_QUERY_AN, PUBLIC_USER_AUTH, PUBLIC_USER_AUTH);
01221 } else {
01222 rodsLog (LOG_ERROR,
01223 "msiSetPublicUserOpr: operation %s for user public not allowed",
01224 &value[i * strArray.size]);
01225 }
01226 }
01227
01228 if (value != NULL)
01229 free (value);
01230
01231 return (0);
01232 }
01233
01234 int
01235 setApiPerm (int apiNumber, int proxyPerm, int clientPerm)
01236 {
01237 int apiInx;
01238
01239 if (proxyPerm < NO_USER_AUTH || proxyPerm > LOCAL_PRIV_USER_AUTH) {
01240 rodsLog (LOG_ERROR,
01241 "setApiPerm: input proxyPerm %d out of range", proxyPerm);
01242 return (SYS_INPUT_PERM_OUT_OF_RANGE);
01243 }
01244
01245 if (clientPerm < NO_USER_AUTH || clientPerm > LOCAL_PRIV_USER_AUTH) {
01246 rodsLog (LOG_ERROR,
01247 "setApiPerm: input clientPerm %d out of range", clientPerm);
01248 return (SYS_INPUT_PERM_OUT_OF_RANGE);
01249 }
01250
01251 apiInx = apiTableLookup (apiNumber);
01252
01253 if (apiInx < 0) {
01254 return (apiInx);
01255 }
01256
01257 RsApiTable[apiInx].proxyUserAuth = proxyPerm;
01258 RsApiTable[apiInx].clientUserAuth = clientPerm;
01259
01260 return (0);
01261 }
01262
01263
01264
01265
01266
01267
01268
01269
01270
01271
01272
01273
01274
01275
01276
01277
01278
01279
01280
01281
01282
01283
01284
01285
01286
01287
01288
01289
01290
01291
01292
01293
01294
01295
01296
01297
01298
01299
01300
01301
01302
01303 int
01304 msiSetGraftPathScheme (msParam_t *xaddUserName, msParam_t *xtrimDirCnt,
01305 ruleExecInfo_t *rei)
01306 {
01307 char *addUserNameStr;
01308 char *trimDirCntStr;
01309 int addUserName;
01310 int trimDirCnt;
01311 msParam_t *msParam;
01312 vaultPathPolicy_t *vaultPathPolicy;
01313
01314 RE_TEST_MACRO (" Calling msiSetGraftPathScheme")
01315
01316 addUserNameStr = (char *) xaddUserName->inOutStruct;
01317 trimDirCntStr = (char *) xtrimDirCnt->inOutStruct;
01318
01319 if (strcmp (addUserNameStr, "no") == 0) {
01320 addUserName = 0;
01321 } else if (strcmp (addUserNameStr, "yes") == 0) {
01322 addUserName = 1;
01323 } else {
01324 rodsLog (LOG_ERROR,
01325 "msiSetGraftPathScheme: invalid input addUserName %s", addUserNameStr);
01326 rei->status = SYS_INPUT_PERM_OUT_OF_RANGE;
01327 return (SYS_INPUT_PERM_OUT_OF_RANGE);
01328 }
01329
01330 if (!isdigit (trimDirCntStr[0])) {
01331 rodsLog (LOG_ERROR,
01332 "msiSetGraftPathScheme: input trimDirCnt %s", trimDirCntStr);
01333 rei->status = SYS_INPUT_PERM_OUT_OF_RANGE;
01334 return (SYS_INPUT_PERM_OUT_OF_RANGE);
01335 } else {
01336 trimDirCnt = atoi (trimDirCntStr);
01337 }
01338
01339 rei->status = 0;
01340
01341 if ((msParam = getMsParamByLabel (&rei->inOutMsParamArray,
01342 VAULT_PATH_POLICY)) != NULL) {
01343 vaultPathPolicy = (vaultPathPolicy_t *) msParam->inOutStruct;
01344 if (vaultPathPolicy == NULL) {
01345 vaultPathPolicy = (vaultPathPolicy_t*)malloc (sizeof (vaultPathPolicy_t));
01346 msParam->inOutStruct = (void *) vaultPathPolicy;
01347 }
01348 vaultPathPolicy->scheme = GRAFT_PATH_S;
01349 vaultPathPolicy->addUserName = addUserName;
01350 vaultPathPolicy->trimDirCnt = trimDirCnt;
01351 return (0);
01352 } else {
01353 vaultPathPolicy = (vaultPathPolicy_t *) malloc (
01354 sizeof (vaultPathPolicy_t));
01355 vaultPathPolicy->scheme = GRAFT_PATH_S;
01356 vaultPathPolicy->addUserName = addUserName;
01357 vaultPathPolicy->trimDirCnt = trimDirCnt;
01358 addMsParam (&rei->inOutMsParamArray, VAULT_PATH_POLICY,
01359 VaultPathPolicy_MS_T, (void *) vaultPathPolicy, NULL);
01360 }
01361 return (0);
01362 }
01363
01364
01365
01366
01367
01368
01369
01370
01371
01372
01373
01374
01375
01376
01377
01378
01379
01380
01381
01382
01383
01384
01385
01386
01387
01388
01389
01390
01391
01392
01393
01394
01395
01396 int
01397 msiSetRandomScheme (ruleExecInfo_t *rei)
01398 {
01399 msParam_t *msParam;
01400 vaultPathPolicy_t *vaultPathPolicy;
01401
01402 RE_TEST_MACRO (" Calling msiSetRandomScheme")
01403
01404 rei->status = 0;
01405
01406 if ((msParam = getMsParamByLabel (&rei->inOutMsParamArray,
01407 VAULT_PATH_POLICY)) != NULL) {
01408 vaultPathPolicy = (vaultPathPolicy_t *) msParam->inOutStruct;
01409 if (vaultPathPolicy == NULL) {
01410 vaultPathPolicy = (vaultPathPolicy_t*)malloc (sizeof (vaultPathPolicy_t));
01411 msParam->inOutStruct = (void *) vaultPathPolicy;
01412 }
01413 memset (vaultPathPolicy, 0, sizeof (vaultPathPolicy_t));
01414 vaultPathPolicy->scheme = RANDOM_S;
01415 return (0);
01416 } else {
01417 vaultPathPolicy = (vaultPathPolicy_t *) malloc (
01418 sizeof (vaultPathPolicy_t));
01419 memset (vaultPathPolicy, 0, sizeof (vaultPathPolicy_t));
01420 vaultPathPolicy->scheme = RANDOM_S;
01421 addMsParam (&rei->inOutMsParamArray, VAULT_PATH_POLICY,
01422 VaultPathPolicy_MS_T, (void *) vaultPathPolicy, NULL);
01423 }
01424 return (0);
01425 }
01426
01427
01428
01429
01430
01431
01432
01433
01434
01435
01436
01437
01438
01439
01440
01441
01442
01443
01444
01445
01446
01447
01448
01449
01450
01451
01452
01453
01454
01455
01456
01457
01458
01459
01460 int
01461 msiSetReServerNumProc (msParam_t *xnumProc, ruleExecInfo_t *rei)
01462 {
01463 char *numProcStr;
01464 int numProc;
01465
01466 numProcStr = (char*)xnumProc->inOutStruct;
01467
01468 if (strcmp (numProcStr, "default") == 0) {
01469 numProc = DEF_NUM_RE_PROCS;
01470 } else {
01471 numProc = atoi (numProcStr);
01472 if (numProc > MAX_RE_PROCS) {
01473 numProc = MAX_RE_PROCS;
01474 } else if (numProc < 0) {
01475 numProc = DEF_NUM_RE_PROCS;
01476 }
01477 }
01478 rei->status = numProc;
01479
01480 return (numProc);
01481 }
01482
01483
01484
01485
01486
01487
01488
01489
01490
01491
01492
01493
01494
01495
01496
01497
01498
01499
01500
01501
01502
01503
01504
01505
01506
01507
01508
01509
01510
01511
01512
01513
01514
01515
01516 int
01517 msiSetRescQuotaPolicy (msParam_t *xflag, ruleExecInfo_t *rei)
01518 {
01519 char *flag;
01520
01521 flag = (char *) xflag->inOutStruct;
01522
01523 RE_TEST_MACRO (" Calling msiSetRescQuotaPolic")
01524
01525 if (strcmp (flag, "on") == 0) {
01526 rei->status = RescQuotaPolicy = RESC_QUOTA_ON;
01527 } else {
01528 rei->status = RescQuotaPolicy = RESC_QUOTA_OFF;
01529 }
01530 return (rei->status);
01531 }
01532
01533
01534
01535
01536
01537
01538
01539
01540
01541
01542
01543
01544
01545
01546
01547
01548
01549
01550
01551
01552
01553
01554
01555
01556
01557
01558
01559
01560
01561
01562
01563
01564
01565
01566
01567
01568
01569
01570 int
01571 msiSetReplComment(msParam_t *inpParam1, msParam_t *inpParam2,
01572 msParam_t *inpParam3, msParam_t *inpParam4,
01573 ruleExecInfo_t *rei)
01574 {
01575 rsComm_t *rsComm;
01576 char *dataCommentStr, *dataIdStr;
01577
01578 modDataObjMeta_t modDataObjMetaInp;
01579 dataObjInfo_t dataObjInfo;
01580 keyValPair_t regParam;
01581
01582 RE_TEST_MACRO (" Calling msiSetReplComment")
01583
01584 if (rei == NULL || rei->rsComm == NULL) {
01585 rodsLog (LOG_ERROR, "msiSetReplComment: input rei or rsComm is NULL.");
01586 return (SYS_INTERNAL_NULL_INPUT_ERR);
01587 }
01588 rsComm = rei->rsComm ;
01589
01590 memset (&dataObjInfo, 0, sizeof (dataObjInfo));
01591
01592
01593 if ((dataIdStr = parseMspForStr(inpParam1)) != NULL) {
01594 dataObjInfo.dataId = (rodsLong_t) atoll(dataIdStr);
01595 }
01596 else {
01597 dataObjInfo.dataId = 0;
01598 }
01599
01600
01601 if (parseMspForStr(inpParam2)) {
01602 strncpy(dataObjInfo.objPath, parseMspForStr(inpParam2), MAX_NAME_LEN);
01603 }
01604
01605 if (!(dataIdStr || dataObjInfo.objPath)) {
01606 rodsLog (LOG_ERROR, "msiSetReplComment: No data object ID or path provided.");
01607 return (USER__NULL_INPUT_ERR);
01608 }
01609
01610 if (inpParam3 != NULL) {
01611 dataObjInfo.replNum = parseMspForPosInt(inpParam3);
01612 }
01613
01614
01615 if ((dataCommentStr = parseMspForStr (inpParam4)) == NULL) {
01616 rodsLog (LOG_ERROR, "msiSetReplComment: parseMspForStr error for param 4.");
01617 return (USER__NULL_INPUT_ERR);
01618 }
01619 memset (®Param, 0, sizeof (regParam));
01620 addKeyVal (®Param, DATA_COMMENTS_KW, dataCommentStr);
01621
01622 rodsLog (LOG_NOTICE, "msiSetReplComment: mod %s (%d) with %s",
01623 dataObjInfo.objPath, dataObjInfo.replNum, dataCommentStr);
01624
01625 modDataObjMetaInp.dataObjInfo = &dataObjInfo;
01626 modDataObjMetaInp.regParam = ®Param;
01627 rei->status = rsModDataObjMeta (rsComm, &modDataObjMetaInp);
01628
01629
01630 if (rei->status < 0) {
01631 if (dataObjInfo.objPath) {
01632 rodsLog (LOG_ERROR,
01633 "msiSetReplComment: rsModDataObjMeta failed for object %s, status = %d",
01634 dataObjInfo.objPath, rei->status);
01635 }
01636 else {
01637 rodsLog (LOG_ERROR,
01638 "msiSetReplComment: rsModDataObjMeta failed for object ID %d, status = %d",
01639 dataObjInfo.dataId, rei->status);
01640 }
01641 }
01642 else {
01643 rodsLog (LOG_NOTICE, "msiSetReplComment: OK mod %s (%d) with %s",
01644 dataObjInfo.objPath, dataObjInfo.replNum, dataCommentStr);
01645 }
01646 return (rei->status);
01647 }
01648
01649
01650
01651
01652
01653
01654
01655
01656
01657
01658
01659
01660
01661
01662
01663
01664
01665
01666
01667
01668
01669
01670
01671
01672
01673
01674
01675
01676
01677
01678
01679
01680
01681
01682
01683
01684 int
01685 msiSetBulkPutPostProcPolicy (msParam_t *xflag, ruleExecInfo_t *rei)
01686 {
01687 char *flag;
01688
01689 flag = (char *) xflag->inOutStruct;
01690
01691 RE_TEST_MACRO (" Calling msiSetBulkPutPostProcPolicy")
01692
01693 if (strcmp (flag, "on") == 0) {
01694 rei->status = POLICY_ON;
01695 } else {
01696 rei->status = POLICY_OFF;
01697 }
01698 return (rei->status);
01699 }
01700
01701
01702
01703
01704
01705
01706
01707
01708
01709
01710
01711
01712
01713
01714
01715
01716
01717
01718
01719
01720
01721
01722
01723
01724
01725
01726
01727
01728
01729
01730
01731
01732
01733
01734
01735
01736
01737
01738
01739
01740
01741
01742
01743 int
01744 msiSysMetaModify (msParam_t *sysMetadata, msParam_t *value, ruleExecInfo_t *rei)
01745 {
01746 keyValPair_t regParam;
01747 modDataObjMeta_t modDataObjMetaInp;
01748
01749
01750 dataObjInfo_t dataObjInfo;
01751 char theTime[TIME_LEN], *inpStr = 0, mdname[MAX_NAME_LEN], replAttr[MAX_NAME_LEN],*pstr1 = 0, *pstr2 = 0;
01752 int allRepl = 0, len1 = 0, len2 = 0, numRepl = 0, status = 0;
01753
01754 rsComm_t *rsComm = 0;
01755
01756 RE_TEST_MACRO (" Calling msiSysMetaModify")
01757
01758 memset(&mdname, 0, sizeof(mdname));
01759
01760
01761 if (rei == NULL || rei->rsComm == NULL) {
01762 rodsLog (LOG_ERROR,
01763 "msiSysMetaModify: input rei or rsComm is NULL");
01764 return (SYS_INTERNAL_NULL_INPUT_ERR);
01765 }
01766
01767 rsComm = rei->rsComm;
01768
01769 if ( sysMetadata == NULL ) {
01770 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
01771 "msiSysMetaModify: input Param1 is NULL");
01772 rei->status = USER__NULL_INPUT_ERR;
01773 return (rei->status);
01774 }
01775
01776 if ( value == NULL ) {
01777 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
01778 "msiSysMetaModify: input Param2 is NULL");
01779 rei->status = USER__NULL_INPUT_ERR;
01780 return (rei->status);
01781 }
01782
01783 if (strcmp (sysMetadata->type, STR_MS_T) == 0 && strcmp (value->type, STR_MS_T) == 0) {
01784 memset(®Param, 0, sizeof(regParam));
01785
01786
01787 memcpy(&dataObjInfo, rei->doi, sizeof(dataObjInfo_t));
01788 inpStr = (char *) sysMetadata->inOutStruct;
01789 allRepl = 1;
01790
01791 pstr1 = strstr(inpStr, "++++");
01792 if ( pstr1 != NULL ) {
01793 len1 = strlen(inpStr) - strlen(pstr1);
01794 if ( len1 > 0 ) {
01795 strncpy(mdname, inpStr, len1);
01796 }
01797 pstr2 = strstr(pstr1 + 4, "=");
01798 if ( pstr2 != NULL ) {
01799 len2 = strlen(pstr1 + 4) - strlen(pstr2);
01800 memset(replAttr, 0, sizeof(replAttr));
01801 strncpy(replAttr, pstr1 + 4, len2);
01802 if ( len2 > 0 ) {
01803 if ( strcmp(replAttr, "numRepl") == 0 ) {
01804 numRepl = atoi(pstr2 + 1);
01805 if ( ( numRepl == 0 && strcmp(pstr2 + 1, "0") == 0 ) || numRepl > 0 ) {
01806 dataObjInfo.replNum = numRepl;
01807 allRepl = 0;
01808 }
01809 }
01810 }
01811 }
01812 }
01813 else {
01814 strncpy(mdname ,inpStr, strlen(inpStr));
01815 allRepl = 1;
01816 }
01817
01818
01819 if ( strcmp(mdname, "datatype") == 0 ) {
01820 addKeyVal(®Param, DATA_TYPE_KW, (char *) value->inOutStruct);
01821 }
01822 else if ( strcmp(mdname, "comment") == 0 ) {
01823 addKeyVal(®Param, DATA_COMMENTS_KW, (char *) value->inOutStruct);
01824
01825
01826 if ( allRepl == 1 ) {
01827 addKeyVal(®Param, ALL_KW, (char *) value->inOutStruct);
01828 }
01829
01830
01831 }
01832 else if ( strcmp(mdname, "expirytime") == 0 ) {
01833 rstrcpy(theTime, (char *) value->inOutStruct, TIME_LEN);
01834 if ( strncmp(theTime, "+", 1) == 0 ) {
01835 rstrcpy(theTime, (char *) value->inOutStruct + 1, TIME_LEN);
01836 status = checkDateFormat(theTime);
01837 getOffsetTimeStr(theTime, theTime);
01838 } else {
01839 status = checkDateFormat(theTime);
01840 }
01841 if (status != 0) {
01842 rei->status = DATE_FORMAT_ERR;
01843 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
01844 "msiSysMetaModify: bad format for the input time: %s. Please refer to isysmeta help.",
01845 (char *) value->inOutStruct);
01846 return (rei->status);
01847 }
01848 else {
01849 addKeyVal(®Param, DATA_EXPIRY_KW, theTime);
01850
01851
01852 if ( allRepl == 1 ) {
01853 addKeyVal(®Param, ALL_KW, theTime);
01854 }
01855
01856 }
01857 }
01858 else {
01859 rei->status = USER_BAD_KEYWORD_ERR;
01860 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
01861 "msiSysMetaModify: unknown system metadata or impossible to modify it: %s",
01862 (char *) sysMetadata->inOutStruct);
01863 }
01864 modDataObjMetaInp.dataObjInfo = &dataObjInfo;
01865 modDataObjMetaInp.regParam = ®Param;
01866 rei->status = rsModDataObjMeta(rsComm, &modDataObjMetaInp);
01867 } else {
01868 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
01869 "msiSysMetaModify: Unsupported input Param1 type %s or Param2 type %s",
01870 sysMetadata->type, value->type);
01871 rei->status = UNKNOWN_PARAM_IN_RULE_ERR;
01872 return (rei->status);
01873 }
01874
01875 return (rei->status);
01876 }