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