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->rescInfo;
00090 delete myRescGrpInfo;
00091 rei->rgi = NULL;
00092 }
00093 return (rei->status);
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
00129 int
00130 msiSetRescSortScheme (msParam_t *xsortScheme, ruleExecInfo_t *rei ) {
00131 #if 0 // JMC - legacy resource
00132 rescGrpInfo_t *myRescGrpInfo;
00133 char *sortScheme;
00134
00135 sortScheme = (char *) xsortScheme->inOutStruct;
00136
00137 RE_TEST_MACRO (" Calling msiSetRescSortScheme")
00138
00139 rei->status = 0;
00140
00141 if (sortScheme != NULL && strlen (sortScheme) > 0) {
00142 strncat (rei->statusStr, sortScheme, MAX_NAME_LEN);
00143 strncat (rei->statusStr, "%", MAX_NAME_LEN);
00144 }
00145 if (rei->rgi == NULL) {
00146
00147
00148 eirods::error err = eirods::set_default_resource( rei->rsComm, "", "", &rei->doinp->condInput, *myRescGrpInfo );
00149 rei->status = err.code();
00150
00151 if (rei->status >= 0) {
00152 rei->rgi = myRescGrpInfo;
00153 } else {
00154 eirods::log( PASS( false, -1, "msiSetRescSortScheme - failed", err );
00155 return (rei->status);
00156 }
00157 } else {
00158 myRescGrpInfo = rei->rgi;
00159 }
00160 sortResc (rei->rsComm, &myRescGrpInfo, sortScheme);
00161 rei->rgi = myRescGrpInfo;
00162 return(0);
00163 #else
00164 return -1;
00165 #endif // JMC - legacy resource
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
00206 int
00207 msiSetNoDirectRescInp (msParam_t *xrescList, ruleExecInfo_t *rei)
00208 {
00209
00210 keyValPair_t *condInput;
00211 char *rescName;
00212 char *value;
00213 strArray_t strArray;
00214 int status, i;
00215 char *rescList;
00216
00217 rescList = (char *) xrescList->inOutStruct;
00218
00219 RE_TEST_MACRO (" Calling msiSetNoDirectRescInp")
00220
00221 rei->status = 0;
00222
00223 if (rescList == NULL || strcmp (rescList, "null") == 0) {
00224 return (0);
00225 }
00226
00227 if (rei->rsComm->proxyUser.authInfo.authFlag >= LOCAL_PRIV_USER_AUTH) {
00228
00229 return (0);
00230 }
00231
00232 condInput = &rei->doinp->condInput;
00233
00234 if ((rescName = getValByKey (condInput, BACKUP_RESC_NAME_KW)) == NULL &&
00235 (rescName = getValByKey (condInput, DEST_RESC_NAME_KW)) == NULL &&
00236 (rescName = getValByKey (condInput, DEF_RESC_NAME_KW)) == NULL &&
00237 (rescName = getValByKey (condInput, RESC_NAME_KW)) == NULL) {
00238 return (0);
00239 }
00240
00241 memset (&strArray, 0, sizeof (strArray));
00242
00243 status = parseMultiStr (rescList, &strArray);
00244
00245 if (status <= 0)
00246 return (0);
00247
00248 value = strArray.value;
00249 for (i = 0; i < strArray.len; i++) {
00250 if (strcmp (rescName, &value[i * strArray.size]) == 0) {
00251
00252 rei->status = USER_DIRECT_RESC_INPUT_ERR;
00253 free (value);
00254 return (USER_DIRECT_RESC_INPUT_ERR);
00255 }
00256 }
00257 if (value != NULL)
00258 free (value);
00259 return (0);
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
00298 int
00299 msiSetDataObjPreferredResc (msParam_t *xpreferredRescList, ruleExecInfo_t *rei)
00300 {
00301 int writeFlag;
00302 char *value;
00303 strArray_t strArray;
00304 int status, i;
00305 char *preferredRescList;
00306
00307 preferredRescList = (char *) xpreferredRescList->inOutStruct;
00308
00309 RE_TEST_MACRO (" Calling msiSetDataObjPreferredResc")
00310
00311 rei->status = 0;
00312
00313 if (preferredRescList == NULL || strcmp (preferredRescList, "null") == 0) {
00314 return (0);
00315 }
00316
00317 writeFlag = getWriteFlag (rei->doinp->openFlags);
00318
00319 memset (&strArray, 0, sizeof (strArray));
00320
00321 status = parseMultiStr (preferredRescList, &strArray);
00322
00323 if (status <= 0)
00324 return (0);
00325
00326 if (rei->doi == NULL || rei->doi->next == NULL)
00327 return (0);
00328
00329 value = strArray.value;
00330 for (i = 0; i < strArray.len; i++) {
00331 if (requeDataObjInfoByResc (&rei->doi, &value[i * strArray.size],
00332 writeFlag, 1) >= 0) {
00333 rei->status = 1;
00334 return (rei->status);
00335 }
00336 }
00337 return (rei->status);
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
00371 int
00372 msiSetDataObjAvoidResc (msParam_t *xavoidResc, ruleExecInfo_t *rei)
00373 {
00374 int writeFlag;
00375 char *avoidResc;
00376
00377 avoidResc = (char *) xavoidResc->inOutStruct;
00378
00379 RE_TEST_MACRO (" Calling msiSetDataObjAvoidResc")
00380
00381 rei->status = 0;
00382
00383 writeFlag = getWriteFlag (rei->doinp->openFlags);
00384
00385 if (avoidResc != NULL && strcmp (avoidResc, "null") != 0) {
00386 if (requeDataObjInfoByResc (&rei->doi, avoidResc, writeFlag, 0)
00387 >= 0) {
00388 rei->status = 1;
00389 }
00390 }
00391 return (rei->status);
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
00425 int
00426 msiSortDataObj (msParam_t *xsortScheme, ruleExecInfo_t *rei)
00427 {
00428 char *sortScheme;
00429
00430 sortScheme = (char *) xsortScheme->inOutStruct;
00431 RE_TEST_MACRO (" Calling msiSortDataObj")
00432
00433 rei->status = 0;
00434 if (sortScheme != NULL) {
00435 if (strcmp (sortScheme, "random") == 0) {
00436 sortDataObjInfoRandom (&rei->doi);
00437
00438
00439 }
00440 }
00441 return (rei->status);
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
00475 int
00476 msiSysChksumDataObj (ruleExecInfo_t *rei)
00477 {
00478 dataObjInfo_t *dataObjInfoHead;
00479 char *chksumStr = NULL;
00480
00481 RE_TEST_MACRO (" Calling msiSysChksumDataObj")
00482
00483 rei->status = 0;
00484
00485
00486
00487 dataObjInfoHead = rei->doi;
00488
00489 if (dataObjInfoHead == NULL) {
00490 return (0);
00491 }
00492
00493 if (strlen (dataObjInfoHead->chksum) == 0) {
00494
00495 rei->status = dataObjChksumAndReg (rei->rsComm, dataObjInfoHead,
00496 &chksumStr);
00497 if (chksumStr != NULL) {
00498 rstrcpy (dataObjInfoHead->chksum, chksumStr,NAME_LEN);
00499 free (chksumStr);
00500 }
00501 }
00502
00503 return (0);
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
00541 int
00542 msiSetDataTypeFromExt (ruleExecInfo_t *rei)
00543 {
00544 dataObjInfo_t *dataObjInfoHead;
00545 int status;
00546 char logicalCollName[MAX_NAME_LEN];
00547 char logicalFileName[MAX_NAME_LEN]="";
00548 char logicalFileName1[MAX_NAME_LEN]="";
00549 char logicalFileNameExt[MAX_NAME_LEN]="";
00550 genQueryInp_t genQueryInp;
00551 genQueryOut_t *genQueryOut=NULL;
00552 char condStr1[MAX_NAME_LEN];
00553 char condStr2[MAX_NAME_LEN];
00554 modDataObjMeta_t modDataObjMetaInp;
00555 keyValPair_t regParam;
00556
00557 RE_TEST_MACRO (" Calling msiSetDataType")
00558
00559 rei->status = 0;
00560
00561 dataObjInfoHead = rei->doi;
00562
00563 if (dataObjInfoHead == NULL) {
00564 return (0);
00565 }
00566
00567 status = splitPathByKey(dataObjInfoHead->objPath,
00568 logicalCollName, logicalFileName, '/');
00569 if (strlen(logicalFileName)<=0) return(0);
00570
00571 status = splitPathByKey(logicalFileName,
00572 logicalFileName1, logicalFileNameExt, '.');
00573 if (strlen(logicalFileNameExt)<=0) return(0);
00574
00575
00576 memset (&genQueryInp, 0, sizeof (genQueryInp));
00577
00578 addInxIval (&genQueryInp.selectInp, COL_TOKEN_NAME, 1);
00579
00580 snprintf (condStr1, MAX_NAME_LEN, "= 'data_type'");
00581 addInxVal (&genQueryInp.sqlCondInp, COL_TOKEN_NAMESPACE, condStr1);
00582
00583 snprintf (condStr2, MAX_NAME_LEN, "like '%s|.%s|%s'", "%",
00584 logicalFileNameExt,"%");
00585 addInxVal (&genQueryInp.sqlCondInp, COL_TOKEN_VALUE2, condStr2);
00586
00587 genQueryInp.maxRows=1;
00588
00589 status = rsGenQuery (rei->rsComm, &genQueryInp, &genQueryOut);
00590 if (status != 0 || genQueryOut == NULL ) return(0);
00591
00592 rodsLog (LOG_NOTICE,
00593 "query status %d rowCnt=%d",status, genQueryOut->rowCnt);
00594
00595 if (genQueryOut->rowCnt != 1) return(0);
00596
00597 status = svrCloseQueryOut (rei->rsComm, genQueryOut);
00598
00599
00600 memset (®Param, 0, sizeof (regParam));
00601 addKeyVal (®Param, DATA_TYPE_KW, genQueryOut->sqlResult[0].value);
00602
00603 modDataObjMetaInp.dataObjInfo = dataObjInfoHead;
00604 modDataObjMetaInp.regParam = ®Param;
00605
00606 status = rsModDataObjMeta (rei->rsComm, &modDataObjMetaInp);
00607
00608 return (0);
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
00644 int
00645 msiStageDataObj (msParam_t *xcacheResc, ruleExecInfo_t *rei)
00646 {
00647 int status;
00648 char *cacheResc;
00649
00650 cacheResc = (char *) xcacheResc->inOutStruct;
00651
00652 RE_TEST_MACRO (" Calling msiStageDataObj")
00653
00654 rei->status = 0;
00655
00656 if (cacheResc == NULL || strcmp (cacheResc, "null") == 0) {
00657 return (rei->status);
00658 }
00659
00660
00661 if (rei->doinp->oprType == REPLICATE_OPR ||
00662 rei->doinp->oprType == COPY_DEST ||
00663 rei->doinp->oprType == COPY_SRC) {
00664 return (rei->status);
00665 }
00666
00667 if (getValByKey (&rei->doinp->condInput, RESC_NAME_KW) != NULL ||
00668 getValByKey (&rei->doinp->condInput, REPL_NUM_KW) != NULL) {
00669
00670 return (rei->status);
00671 }
00672
00673 status = msiSysReplDataObj (xcacheResc, NULL, rei);
00674
00675 return (status);
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
00718 int
00719 msiSysReplDataObj (msParam_t *xcacheResc, msParam_t *xflag,
00720 ruleExecInfo_t *rei)
00721 {
00722 int writeFlag;
00723 dataObjInfo_t *dataObjInfoHead;
00724 char *cacheResc;
00725 char *flag = NULL;
00726
00727 cacheResc = (char *) xcacheResc->inOutStruct;
00728 if (xflag != NULL && xflag->inOutStruct != NULL) {
00729 flag = (char *) xflag->inOutStruct;
00730 }
00731
00732 RE_TEST_MACRO (" Calling msiSysReplDataObj")
00733
00734 rei->status = 0;
00735
00736 if (cacheResc == NULL || strcmp (cacheResc, "null") == 0 ||
00737 strlen (cacheResc) == 0) {
00738 return (rei->status);
00739 }
00740
00741 dataObjInfoHead = rei->doi;
00742
00743 if (dataObjInfoHead == NULL) {
00744 return (rei->status);
00745 }
00746
00747 writeFlag = getWriteFlag (rei->doinp->openFlags);
00748
00749 if (requeDataObjInfoByResc (&dataObjInfoHead, cacheResc, writeFlag, 1)
00750 >= 0) {
00751
00752 rei->status = 1;
00753 return (rei->status);
00754 }
00755
00756 rei->status = rsReplAndRequeDataObjInfo (rei->rsComm, &dataObjInfoHead,
00757 cacheResc, flag);
00758 if (rei->status >= 0) {
00759 rei->doi = dataObjInfoHead;
00760 }
00761 return (rei->status);
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
00804 int
00805 msiSetNumThreads (msParam_t *xsizePerThrInMbStr, msParam_t *xmaxNumThrStr,
00806 msParam_t *xwindowSizeStr, ruleExecInfo_t *rei)
00807 {
00808 int sizePerThr;
00809 int maxNumThr;
00810 dataObjInp_t *doinp;
00811 int numThr;
00812 char *sizePerThrInMbStr;
00813 char *maxNumThrStr;
00814 char *windowSizeStr;
00815
00816 sizePerThrInMbStr = (char *) xsizePerThrInMbStr->inOutStruct;
00817 maxNumThrStr = (char *) xmaxNumThrStr->inOutStruct;
00818 windowSizeStr = (char *) xwindowSizeStr->inOutStruct;
00819
00820 if (rei->rsComm != NULL) {
00821 if (strcmp (windowSizeStr, "null") == 0 ||
00822 strcmp (windowSizeStr, "default") == 0) {
00823 rei->rsComm->windowSize = 0;
00824 } else {
00825 rei->rsComm->windowSize = atoi (windowSizeStr);
00826 }
00827 }
00828
00829 if (strcmp (sizePerThrInMbStr, "default") == 0) {
00830 sizePerThr = SZ_PER_TRAN_THR;
00831 } else {
00832 sizePerThr = atoi (sizePerThrInMbStr) * (1024*1024);
00833 if (sizePerThr <= 0) {
00834 rodsLog (LOG_ERROR,
00835 "msiSetNumThreads: Bad input sizePerThrInMb %s", sizePerThrInMbStr);
00836 sizePerThr = SZ_PER_TRAN_THR;
00837 }
00838 }
00839
00840 doinp = rei->doinp;
00841 if (doinp == NULL) {
00842 rodsLog (LOG_ERROR,
00843 "msiSetNumThreads: doinp is NULL");
00844 rei->status = DEF_NUM_TRAN_THR;
00845 return DEF_NUM_TRAN_THR;
00846 }
00847
00848 if (strcmp (maxNumThrStr, "default") == 0) {
00849 maxNumThr = DEF_NUM_TRAN_THR;
00850 } else {
00851 maxNumThr = atoi (maxNumThrStr);
00852 if (maxNumThr < 0) {
00853 rodsLog (LOG_ERROR,
00854 "msiSetNumThreads: Bad input maxNumThr %s", maxNumThrStr);
00855 maxNumThr = DEF_NUM_TRAN_THR;
00856 } else if (maxNumThr == 0) {
00857 rei->status = 0;
00858 return rei->status;
00859 } else if (maxNumThr > MAX_NUM_CONFIG_TRAN_THR) {
00860 rodsLog (LOG_ERROR,
00861 "msiSetNumThreads: input maxNumThr %s too large", maxNumThrStr);
00862 maxNumThr = MAX_NUM_CONFIG_TRAN_THR;
00863 }
00864 }
00865
00866
00867 if (doinp->numThreads > 0) {
00868 numThr = doinp->dataSize / TRANS_BUF_SZ + 1;
00869 if (numThr > doinp->numThreads) {
00870 numThr = doinp->numThreads;
00871 }
00872 } else {
00873 numThr = doinp->dataSize / sizePerThr + 1;
00874 }
00875
00876 if (numThr > maxNumThr)
00877 numThr = maxNumThr;
00878
00879 rei->status = numThr;
00880 return (rei->status);
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
00914 int
00915 msiDeleteDisallowed (ruleExecInfo_t *rei)
00916 {
00917 RE_TEST_MACRO (" Calling msiDeleteDisallowed")
00918
00919 rei->status = SYS_DELETE_DISALLOWED;
00920
00921 return (rei->status);
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
00954 int
00955 msiOprDisallowed (ruleExecInfo_t *rei)
00956 {
00957 RE_TEST_MACRO (" Calling msiOprDisallowed")
00958
00959 rei->status = MSI_OPERATION_NOT_ALLOWED;
00960
00961 return (rei->status);
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
00995 int
00996 msiSetMultiReplPerResc (ruleExecInfo_t *rei)
00997 {
00998 rstrcpy (rei->statusStr, MULTI_COPIES_PER_RESC, MAX_NAME_LEN);
00999 return (0);
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
01034 int
01035 msiNoChkFilePathPerm (ruleExecInfo_t *rei)
01036 {
01037 rei->status = NO_CHK_PATH_PERM;
01038 return (NO_CHK_PATH_PERM);
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
01073 int
01074 msiSetChkFilePathPerm (msParam_t *xchkType, ruleExecInfo_t *rei)
01075 {
01076 char *chkType;
01077
01078 chkType = (char *) xchkType->inOutStruct;
01079
01080 if (strcmp (chkType, DO_CHK_PATH_PERM_STR) == 0) {
01081 rei->status = DO_CHK_PATH_PERM;
01082 } else if (strcmp (chkType, NO_CHK_PATH_PERM_STR) == 0) {
01083 rei->status = NO_CHK_PATH_PERM;
01084 } else if (strcmp (chkType, CHK_NON_VAULT_PATH_PERM_STR) == 0) {
01085 rei->status = CHK_NON_VAULT_PATH_PERM;
01086 } else if (strcmp (chkType, DISALLOW_PATH_REG_STR) == 0) {
01087 rei->status = DISALLOW_PATH_REG;
01088 } else {
01089 rodsLog (LOG_ERROR,
01090 "msiNoChkFilePathPerm:invalid check type %s,set to DISALLOW_PATH_REG");
01091 rei->status = DISALLOW_PATH_REG;
01092 }
01093 return (rei->status);
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
01127 int
01128 msiNoTrashCan (ruleExecInfo_t *rei)
01129 {
01130 rei->status = NO_TRASH_CAN;
01131 return (NO_TRASH_CAN);
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
01168 int
01169 msiSetPublicUserOpr (msParam_t *xoprList, ruleExecInfo_t *rei)
01170 {
01171
01172 char *value;
01173 strArray_t strArray;
01174 int status, i;
01175 char *oprList;
01176
01177 oprList = (char *) xoprList->inOutStruct;
01178
01179 RE_TEST_MACRO (" Calling msiSetPublicUserOpr")
01180
01181 rei->status = 0;
01182
01183 if (oprList == NULL || strcmp (oprList, "null") == 0) {
01184 return (0);
01185 }
01186
01187 if (rei->rsComm->clientUser.authInfo.authFlag < LOCAL_PRIV_USER_AUTH) {
01188
01189 return (SYS_NO_API_PRIV);
01190 }
01191
01192 memset (&strArray, 0, sizeof (strArray));
01193
01194 status = parseMultiStr (oprList, &strArray);
01195
01196 if (status <= 0)
01197 return (0);
01198
01199 value = strArray.value;
01200 for (i = 0; i < strArray.len; i++) {
01201 if (strcmp ("read", &value[i * strArray.size]) == 0) {
01202
01203 setApiPerm (DATA_OBJ_OPEN_AN, PUBLIC_USER_AUTH, PUBLIC_USER_AUTH);
01204 setApiPerm (FILE_OPEN_AN, REMOTE_PRIV_USER_AUTH,
01205 PUBLIC_USER_AUTH);
01206 setApiPerm (FILE_READ_AN, REMOTE_PRIV_USER_AUTH,
01207 PUBLIC_USER_AUTH);
01208 setApiPerm (DATA_OBJ_LSEEK_AN, PUBLIC_USER_AUTH,
01209 PUBLIC_USER_AUTH);
01210 setApiPerm (FILE_LSEEK_AN, REMOTE_PRIV_USER_AUTH,
01211 PUBLIC_USER_AUTH);
01212 setApiPerm (DATA_OBJ_CLOSE_AN, PUBLIC_USER_AUTH,
01213 PUBLIC_USER_AUTH);
01214 setApiPerm (FILE_CLOSE_AN, REMOTE_PRIV_USER_AUTH,
01215 PUBLIC_USER_AUTH);
01216 setApiPerm (OBJ_STAT_AN, PUBLIC_USER_AUTH,
01217 PUBLIC_USER_AUTH);
01218 setApiPerm (DATA_OBJ_GET_AN, PUBLIC_USER_AUTH, PUBLIC_USER_AUTH);
01219 setApiPerm (DATA_GET_AN, REMOTE_PRIV_USER_AUTH, PUBLIC_USER_AUTH);
01220 } else if (strcmp ("query", &value[i * strArray.size]) == 0) {
01221 setApiPerm (GEN_QUERY_AN, PUBLIC_USER_AUTH, PUBLIC_USER_AUTH);
01222 } else {
01223 rodsLog (LOG_ERROR,
01224 "msiSetPublicUserOpr: operation %s for user public not allowed",
01225 &value[i * strArray.size]);
01226 }
01227 }
01228
01229 if (value != NULL)
01230 free (value);
01231
01232 return (0);
01233 }
01234
01235 int
01236 setApiPerm (int apiNumber, int proxyPerm, int clientPerm)
01237 {
01238 int apiInx;
01239
01240 if (proxyPerm < NO_USER_AUTH || proxyPerm > LOCAL_PRIV_USER_AUTH) {
01241 rodsLog (LOG_ERROR,
01242 "setApiPerm: input proxyPerm %d out of range", proxyPerm);
01243 return (SYS_INPUT_PERM_OUT_OF_RANGE);
01244 }
01245
01246 if (clientPerm < NO_USER_AUTH || clientPerm > LOCAL_PRIV_USER_AUTH) {
01247 rodsLog (LOG_ERROR,
01248 "setApiPerm: input clientPerm %d out of range", clientPerm);
01249 return (SYS_INPUT_PERM_OUT_OF_RANGE);
01250 }
01251
01252 apiInx = apiTableLookup (apiNumber);
01253
01254 if (apiInx < 0) {
01255 return (apiInx);
01256 }
01257
01258 RsApiTable[apiInx].proxyUserAuth = proxyPerm;
01259 RsApiTable[apiInx].clientUserAuth = clientPerm;
01260
01261 return (0);
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
01304 int
01305 msiSetGraftPathScheme (msParam_t *xaddUserName, msParam_t *xtrimDirCnt,
01306 ruleExecInfo_t *rei)
01307 {
01308 char *addUserNameStr;
01309 char *trimDirCntStr;
01310 int addUserName;
01311 int trimDirCnt;
01312 msParam_t *msParam;
01313 vaultPathPolicy_t *vaultPathPolicy;
01314
01315 RE_TEST_MACRO (" Calling msiSetGraftPathScheme")
01316
01317 addUserNameStr = (char *) xaddUserName->inOutStruct;
01318 trimDirCntStr = (char *) xtrimDirCnt->inOutStruct;
01319
01320 if (strcmp (addUserNameStr, "no") == 0) {
01321 addUserName = 0;
01322 } else if (strcmp (addUserNameStr, "yes") == 0) {
01323 addUserName = 1;
01324 } else {
01325 rodsLog (LOG_ERROR,
01326 "msiSetGraftPathScheme: invalid input addUserName %s", addUserNameStr);
01327 rei->status = SYS_INPUT_PERM_OUT_OF_RANGE;
01328 return (SYS_INPUT_PERM_OUT_OF_RANGE);
01329 }
01330
01331 if (!isdigit (trimDirCntStr[0])) {
01332 rodsLog (LOG_ERROR,
01333 "msiSetGraftPathScheme: input trimDirCnt %s", trimDirCntStr);
01334 rei->status = SYS_INPUT_PERM_OUT_OF_RANGE;
01335 return (SYS_INPUT_PERM_OUT_OF_RANGE);
01336 } else {
01337 trimDirCnt = atoi (trimDirCntStr);
01338 }
01339
01340 rei->status = 0;
01341
01342 if ((msParam = getMsParamByLabel (&rei->inOutMsParamArray,
01343 VAULT_PATH_POLICY)) != NULL) {
01344 vaultPathPolicy = (vaultPathPolicy_t *) msParam->inOutStruct;
01345 if (vaultPathPolicy == NULL) {
01346 vaultPathPolicy = (vaultPathPolicy_t*)malloc (sizeof (vaultPathPolicy_t));
01347 msParam->inOutStruct = (void *) vaultPathPolicy;
01348 }
01349 vaultPathPolicy->scheme = GRAFT_PATH_S;
01350 vaultPathPolicy->addUserName = addUserName;
01351 vaultPathPolicy->trimDirCnt = trimDirCnt;
01352 return (0);
01353 } else {
01354 vaultPathPolicy = (vaultPathPolicy_t *) malloc (
01355 sizeof (vaultPathPolicy_t));
01356 vaultPathPolicy->scheme = GRAFT_PATH_S;
01357 vaultPathPolicy->addUserName = addUserName;
01358 vaultPathPolicy->trimDirCnt = trimDirCnt;
01359 addMsParam (&rei->inOutMsParamArray, VAULT_PATH_POLICY,
01360 VaultPathPolicy_MS_T, (void *) vaultPathPolicy, NULL);
01361 }
01362 return (0);
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
01397 int
01398 msiSetRandomScheme (ruleExecInfo_t *rei)
01399 {
01400 msParam_t *msParam;
01401 vaultPathPolicy_t *vaultPathPolicy;
01402
01403 RE_TEST_MACRO (" Calling msiSetRandomScheme")
01404
01405 rei->status = 0;
01406
01407 if ((msParam = getMsParamByLabel (&rei->inOutMsParamArray,
01408 VAULT_PATH_POLICY)) != NULL) {
01409 vaultPathPolicy = (vaultPathPolicy_t *) msParam->inOutStruct;
01410 if (vaultPathPolicy == NULL) {
01411 vaultPathPolicy = (vaultPathPolicy_t*)malloc (sizeof (vaultPathPolicy_t));
01412 msParam->inOutStruct = (void *) vaultPathPolicy;
01413 }
01414 memset (vaultPathPolicy, 0, sizeof (vaultPathPolicy_t));
01415 vaultPathPolicy->scheme = RANDOM_S;
01416 return (0);
01417 } else {
01418 vaultPathPolicy = (vaultPathPolicy_t *) malloc (
01419 sizeof (vaultPathPolicy_t));
01420 memset (vaultPathPolicy, 0, sizeof (vaultPathPolicy_t));
01421 vaultPathPolicy->scheme = RANDOM_S;
01422 addMsParam (&rei->inOutMsParamArray, VAULT_PATH_POLICY,
01423 VaultPathPolicy_MS_T, (void *) vaultPathPolicy, NULL);
01424 }
01425 return (0);
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
01461 int
01462 msiSetReServerNumProc (msParam_t *xnumProc, ruleExecInfo_t *rei)
01463 {
01464 char *numProcStr;
01465 int numProc;
01466
01467 numProcStr = (char*)xnumProc->inOutStruct;
01468
01469 if (strcmp (numProcStr, "default") == 0) {
01470 numProc = DEF_NUM_RE_PROCS;
01471 } else {
01472 numProc = atoi (numProcStr);
01473 if (numProc > MAX_RE_PROCS) {
01474 numProc = MAX_RE_PROCS;
01475 } else if (numProc < 0) {
01476 numProc = DEF_NUM_RE_PROCS;
01477 }
01478 }
01479 rei->status = numProc;
01480
01481 return (numProc);
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
01517 int
01518 msiSetRescQuotaPolicy (msParam_t *xflag, ruleExecInfo_t *rei)
01519 {
01520 char *flag;
01521
01522 flag = (char *) xflag->inOutStruct;
01523
01524 RE_TEST_MACRO (" Calling msiSetRescQuotaPolic")
01525
01526 if (strcmp (flag, "on") == 0) {
01527 rei->status = RescQuotaPolicy = RESC_QUOTA_ON;
01528 } else {
01529 rei->status = RescQuotaPolicy = RESC_QUOTA_OFF;
01530 }
01531 return (rei->status);
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
01571 int
01572 msiSetReplComment(msParam_t *inpParam1, msParam_t *inpParam2,
01573 msParam_t *inpParam3, msParam_t *inpParam4,
01574 ruleExecInfo_t *rei)
01575 {
01576 rsComm_t *rsComm;
01577 char *dataCommentStr, *dataIdStr;
01578
01579 modDataObjMeta_t modDataObjMetaInp;
01580 dataObjInfo_t dataObjInfo;
01581 keyValPair_t regParam;
01582
01583 RE_TEST_MACRO (" Calling msiSetReplComment")
01584
01585 if (rei == NULL || rei->rsComm == NULL) {
01586 rodsLog (LOG_ERROR, "msiSetReplComment: input rei or rsComm is NULL.");
01587 return (SYS_INTERNAL_NULL_INPUT_ERR);
01588 }
01589 rsComm = rei->rsComm ;
01590
01591 memset (&dataObjInfo, 0, sizeof (dataObjInfo));
01592
01593
01594 if ((dataIdStr = parseMspForStr(inpParam1)) != NULL) {
01595 dataObjInfo.dataId = (rodsLong_t) atoll(dataIdStr);
01596 }
01597 else {
01598 dataObjInfo.dataId = 0;
01599 }
01600
01601
01602 if (parseMspForStr(inpParam2)) {
01603 strncpy(dataObjInfo.objPath, parseMspForStr(inpParam2), MAX_NAME_LEN);
01604 }
01605
01606 if (!(dataIdStr || dataObjInfo.objPath)) {
01607 rodsLog (LOG_ERROR, "msiSetReplComment: No data object ID or path provided.");
01608 return (USER__NULL_INPUT_ERR);
01609 }
01610
01611 if (inpParam3 != NULL) {
01612 dataObjInfo.replNum = parseMspForPosInt(inpParam3);
01613 }
01614
01615
01616 if ((dataCommentStr = parseMspForStr (inpParam4)) == NULL) {
01617 rodsLog (LOG_ERROR, "msiSetReplComment: parseMspForStr error for param 4.");
01618 return (USER__NULL_INPUT_ERR);
01619 }
01620 memset (®Param, 0, sizeof (regParam));
01621 addKeyVal (®Param, DATA_COMMENTS_KW, dataCommentStr);
01622
01623 rodsLog (LOG_NOTICE, "msiSetReplComment: mod %s (%d) with %s",
01624 dataObjInfo.objPath, dataObjInfo.replNum, dataCommentStr);
01625
01626 modDataObjMetaInp.dataObjInfo = &dataObjInfo;
01627 modDataObjMetaInp.regParam = ®Param;
01628 rei->status = rsModDataObjMeta (rsComm, &modDataObjMetaInp);
01629
01630
01631 if (rei->status < 0) {
01632 if (dataObjInfo.objPath) {
01633 rodsLog (LOG_ERROR,
01634 "msiSetReplComment: rsModDataObjMeta failed for object %s, status = %d",
01635 dataObjInfo.objPath, rei->status);
01636 }
01637 else {
01638 rodsLog (LOG_ERROR,
01639 "msiSetReplComment: rsModDataObjMeta failed for object ID %d, status = %d",
01640 dataObjInfo.dataId, rei->status);
01641 }
01642 }
01643 else {
01644 rodsLog (LOG_NOTICE, "msiSetReplComment: OK mod %s (%d) with %s",
01645 dataObjInfo.objPath, dataObjInfo.replNum, dataCommentStr);
01646 }
01647 return (rei->status);
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
01685 int
01686 msiSetBulkPutPostProcPolicy (msParam_t *xflag, ruleExecInfo_t *rei)
01687 {
01688 char *flag;
01689
01690 flag = (char *) xflag->inOutStruct;
01691
01692 RE_TEST_MACRO (" Calling msiSetBulkPutPostProcPolicy")
01693
01694 if (strcmp (flag, "on") == 0) {
01695 rei->status = POLICY_ON;
01696 } else {
01697 rei->status = POLICY_OFF;
01698 }
01699 return (rei->status);
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
01744 int
01745 msiSysMetaModify (msParam_t *sysMetadata, msParam_t *value, ruleExecInfo_t *rei)
01746 {
01747 keyValPair_t regParam;
01748 modDataObjMeta_t modDataObjMetaInp;
01749
01750
01751 dataObjInfo_t dataObjInfo;
01752 char theTime[TIME_LEN], *inpStr = 0, mdname[MAX_NAME_LEN], replAttr[MAX_NAME_LEN],*pstr1 = 0, *pstr2 = 0;
01753 int allRepl = 0, len1 = 0, len2 = 0, numRepl = 0, status = 0;
01754
01755 rsComm_t *rsComm = 0;
01756
01757 RE_TEST_MACRO (" Calling msiSysMetaModify")
01758
01759 memset(&mdname, 0, sizeof(mdname));
01760
01761
01762 if (rei == NULL || rei->rsComm == NULL) {
01763 rodsLog (LOG_ERROR,
01764 "msiSysMetaModify: input rei or rsComm is NULL");
01765 return (SYS_INTERNAL_NULL_INPUT_ERR);
01766 }
01767
01768 rsComm = rei->rsComm;
01769
01770 if ( sysMetadata == NULL ) {
01771 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
01772 "msiSysMetaModify: input Param1 is NULL");
01773 rei->status = USER__NULL_INPUT_ERR;
01774 return (rei->status);
01775 }
01776
01777 if ( value == NULL ) {
01778 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
01779 "msiSysMetaModify: input Param2 is NULL");
01780 rei->status = USER__NULL_INPUT_ERR;
01781 return (rei->status);
01782 }
01783
01784 if (strcmp (sysMetadata->type, STR_MS_T) == 0 && strcmp (value->type, STR_MS_T) == 0) {
01785 memset(®Param, 0, sizeof(regParam));
01786
01787
01788 memcpy(&dataObjInfo, rei->doi, sizeof(dataObjInfo_t));
01789 inpStr = (char *) sysMetadata->inOutStruct;
01790 allRepl = 1;
01791
01792 pstr1 = strstr(inpStr, "++++");
01793 if ( pstr1 != NULL ) {
01794 len1 = strlen(inpStr) - strlen(pstr1);
01795 if ( len1 > 0 ) {
01796 strncpy(mdname, inpStr, len1);
01797 }
01798 pstr2 = strstr(pstr1 + 4, "=");
01799 if ( pstr2 != NULL ) {
01800 len2 = strlen(pstr1 + 4) - strlen(pstr2);
01801 memset(replAttr, 0, sizeof(replAttr));
01802 strncpy(replAttr, pstr1 + 4, len2);
01803 if ( len2 > 0 ) {
01804 if ( strcmp(replAttr, "numRepl") == 0 ) {
01805 numRepl = atoi(pstr2 + 1);
01806 if ( ( numRepl == 0 && strcmp(pstr2 + 1, "0") == 0 ) || numRepl > 0 ) {
01807 dataObjInfo.replNum = numRepl;
01808 allRepl = 0;
01809 }
01810 }
01811 }
01812 }
01813 }
01814 else {
01815 strncpy(mdname ,inpStr, strlen(inpStr));
01816 allRepl = 1;
01817 }
01818
01819
01820 if ( strcmp(mdname, "datatype") == 0 ) {
01821 addKeyVal(®Param, DATA_TYPE_KW, (char *) value->inOutStruct);
01822 }
01823 else if ( strcmp(mdname, "comment") == 0 ) {
01824 addKeyVal(®Param, DATA_COMMENTS_KW, (char *) value->inOutStruct);
01825
01826
01827 if ( allRepl == 1 ) {
01828 addKeyVal(®Param, ALL_KW, (char *) value->inOutStruct);
01829 }
01830
01831
01832 }
01833 else if ( strcmp(mdname, "expirytime") == 0 ) {
01834 rstrcpy(theTime, (char *) value->inOutStruct, TIME_LEN);
01835 if ( strncmp(theTime, "+", 1) == 0 ) {
01836 rstrcpy(theTime, (char *) value->inOutStruct + 1, TIME_LEN);
01837 status = checkDateFormat(theTime);
01838 getOffsetTimeStr(theTime, theTime);
01839 } else {
01840 status = checkDateFormat(theTime);
01841 }
01842 if (status != 0) {
01843 rei->status = DATE_FORMAT_ERR;
01844 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
01845 "msiSysMetaModify: bad format for the input time: %s. Please refer to isysmeta help.",
01846 (char *) value->inOutStruct);
01847 return (rei->status);
01848 }
01849 else {
01850 addKeyVal(®Param, DATA_EXPIRY_KW, theTime);
01851
01852
01853 if ( allRepl == 1 ) {
01854 addKeyVal(®Param, ALL_KW, theTime);
01855 }
01856
01857 }
01858 }
01859 else {
01860 rei->status = USER_BAD_KEYWORD_ERR;
01861 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
01862 "msiSysMetaModify: unknown system metadata or impossible to modify it: %s",
01863 (char *) sysMetadata->inOutStruct);
01864 }
01865 modDataObjMetaInp.dataObjInfo = &dataObjInfo;
01866 modDataObjMetaInp.regParam = ®Param;
01867 rei->status = rsModDataObjMeta(rsComm, &modDataObjMetaInp);
01868 } else {
01869 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
01870 "msiSysMetaModify: Unsupported input Param1 type %s or Param2 type %s",
01871 sysMetadata->type, value->type);
01872 rei->status = UNKNOWN_PARAM_IN_RULE_ERR;
01873 return (rei->status);
01874 }
01875
01876 return (rei->status);
01877 }