00001
00002
00003
00004
00005
00006
00007
00008
00009 #include <stdlib.h>
00010 #include <unistd.h>
00011 #include "eraMS.h"
00012 #include "eraUtil.h"
00013 #include "icatHighLevelRoutines.h"
00014
00015
00016
00017
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 int
00054 msiRecursiveCollCopy(msParam_t *inpParam1, msParam_t *inpParam2, msParam_t *outParam, ruleExecInfo_t *rei)
00055 {
00056 collInp_t collInpCache1, *collInp1;
00057 collInp_t collInpCache2, *collInp2;
00058 rsComm_t *rsComm;
00059
00060
00061 RE_TEST_MACRO (" Calling msiRecursiveCollCopy")
00062
00063
00064
00065 if (rei == NULL || rei->rsComm == NULL) {
00066 rodsLog (LOG_ERROR, "msiRecursiveCollCopy: input rei or rsComm is NULL");
00067 return (SYS_INTERNAL_NULL_INPUT_ERR);
00068 }
00069
00070 rsComm = rei->rsComm;
00071
00072
00073
00074 rei->status = parseMspForCollInp (inpParam1, &collInpCache1, &collInp1, 0);
00075
00076 if (rei->status < 0) {
00077 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
00078 "msiRecursiveCollCopy: input inpParam1 error. status = %d", rei->status);
00079 return (rei->status);
00080 }
00081
00082
00083
00084 rei->status = parseMspForCollInp (inpParam2, &collInpCache2, &collInp2, 0);
00085
00086 if (rei->status < 0) {
00087 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
00088 "msiRecursiveCollCopy: input inpParam2 error. status = %d", rei->status);
00089 return (rei->status);
00090 }
00091
00092
00093
00094 rei->status = recursiveCollCopy(collInp1, collInp2, rsComm);
00095
00096
00097
00098 if (rei->status >= 0) {
00099 fillIntInMsParam (outParam, rei->status);
00100 }
00101 else {
00102 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
00103 "msiRecursiveCollCopy: recursiveCollCopy failed for %s, status = %d",
00104 inpParam1->inOutStruct, rei->status);
00105 }
00106
00107 return (rei->status);
00108 }
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143
00144 int
00145 msiCopyAVUMetadata(msParam_t *inpParam1, msParam_t *inpParam2, msParam_t *outParam, ruleExecInfo_t *rei)
00146 {
00147 rsComm_t *rsComm;
00148
00149
00150 RE_TEST_MACRO (" Calling msiCopyAVUMetadata")
00151
00152
00153
00154 if (rei == NULL || rei->rsComm == NULL) {
00155 rodsLog (LOG_ERROR, "msiCopyAVUMetadata: input rei or rsComm is NULL");
00156 return (SYS_INTERNAL_NULL_INPUT_ERR);
00157 }
00158
00159 rsComm = rei->rsComm;
00160
00161
00162
00163 if ((parseMspForStr(inpParam1) == NULL)) {
00164 rodsLog (LOG_ERROR, "msiCopyAVUMetadata: input inpParam1 is NULL");
00165 return (USER__NULL_INPUT_ERR);
00166 }
00167
00168 if ((parseMspForStr (inpParam2) == NULL)) {
00169 rodsLog (LOG_ERROR, "msiCopyAVUMetadata: input inpParam2 is NULL");
00170 return (USER__NULL_INPUT_ERR);
00171 }
00172
00173
00174
00175 rei->status = copyAVUMetadata((char*)inpParam2->inOutStruct, (char*)inpParam1->inOutStruct, rsComm);
00176
00177
00178 fillIntInMsParam (outParam, rei->status);
00179 return (rei->status);
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
00207
00208
00209
00210
00211
00212
00213
00214
00215
00216
00217
00218
00219
00220
00221 int
00222 msiExportRecursiveCollMeta(msParam_t *inpParam, msParam_t *outParam, ruleExecInfo_t *rei)
00223 {
00224 collInp_t collInpCache, *outCollInp;
00225 genQueryInp_t genQueryInp;
00226 genQueryOut_t *genQueryOut;
00227 char collQCond[MAX_NAME_LEN];
00228 char objPath[MAX_NAME_LEN];
00229 rsComm_t *rsComm;
00230 bytesBuf_t *mybuf;
00231 char *tResult;
00232 int i, j;
00233
00234
00235
00236
00237 RE_TEST_MACRO (" Calling msiExportRecursiveCollMeta")
00238
00239 rsComm = rei->rsComm;
00240
00241
00242
00243 rei->status = parseMspForCollInp (inpParam, &collInpCache, &outCollInp, 0);
00244
00245 if (rei->status < 0) {
00246 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
00247 "msiExportRecursiveCollMeta: input inpParam1 error. status = %d", rei->status);
00248 return (rei->status);
00249 }
00250
00251
00252
00253 if (isColl(rei->rsComm, outCollInp->collName, NULL) < 0) {
00254 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
00255 "msiExportRecursiveCollMeta: Invalid input in inpParam1: %s. No such collection.", outCollInp->collName);
00256 return (rei->status);
00257 }
00258
00259
00260
00261 mybuf = (bytesBuf_t *)malloc(sizeof(bytesBuf_t));
00262 memset (mybuf, 0, sizeof (bytesBuf_t));
00263
00264
00265
00266
00267 memset (&genQueryInp, 0, sizeof (genQueryInp_t));
00268 genAllInCollQCond (outCollInp->collName, collQCond);
00269
00270 addInxVal (&genQueryInp.sqlCondInp, COL_COLL_NAME, collQCond);
00271 addInxIval (&genQueryInp.selectInp, COL_COLL_NAME, 1);
00272
00273 genQueryInp.maxRows = MAX_SQL_ROWS;
00274
00275
00276 rei->status = rsGenQuery (rsComm, &genQueryInp, &genQueryOut);
00277
00278 if (rei->status != CAT_NO_ROWS_FOUND) {
00279
00280 for (i=0;i<genQueryOut->rowCnt;i++) {
00281
00282 for (j=0;j<genQueryOut->attriCnt;j++) {
00283 tResult = genQueryOut->sqlResult[j].value;
00284 tResult += i*genQueryOut->sqlResult[j].len;
00285
00286
00287 getCollectionPSmeta(tResult, mybuf, rsComm);
00288 }
00289 }
00290
00291 while (rei->status==0 && genQueryOut->continueInx > 0) {
00292 genQueryInp.continueInx=genQueryOut->continueInx;
00293 rei->status = rsGenQuery(rsComm, &genQueryInp, &genQueryOut);
00294
00295 for (i=0;i<genQueryOut->rowCnt;i++) {
00296
00297 for (j=0;j<genQueryOut->attriCnt;j++) {
00298 tResult = genQueryOut->sqlResult[j].value;
00299 tResult += i*genQueryOut->sqlResult[j].len;
00300
00301
00302 getCollectionPSmeta(tResult, mybuf, rsComm);
00303 }
00304 }
00305 }
00306 }
00307
00308
00309
00310
00311 memset (&genQueryInp, 0, sizeof (genQueryInp_t));
00312 genAllInCollQCond (outCollInp->collName, collQCond);
00313
00314 addInxVal (&genQueryInp.sqlCondInp, COL_COLL_NAME, collQCond);
00315 addInxIval (&genQueryInp.selectInp, COL_COLL_NAME, 1);
00316 addInxIval (&genQueryInp.selectInp, COL_DATA_NAME, 1);
00317
00318 genQueryInp.maxRows = MAX_SQL_ROWS;
00319
00320
00321 rei->status = rsGenQuery (rsComm, &genQueryInp, &genQueryOut);
00322
00323 if (rei->status != CAT_NO_ROWS_FOUND) {
00324
00325 for (i=0;i<genQueryOut->rowCnt;i++) {
00326
00327
00328 tResult = genQueryOut->sqlResult[0].value;
00329 tResult += i*genQueryOut->sqlResult[0].len;
00330 snprintf(objPath, MAX_NAME_LEN, "%s/", tResult);
00331
00332
00333 tResult = genQueryOut->sqlResult[1].value;
00334 tResult += i*genQueryOut->sqlResult[1].len;
00335 strcat(objPath, tResult);
00336
00337
00338 getDataObjPSmeta(objPath, mybuf, rsComm);
00339 }
00340
00341 while (rei->status==0 && genQueryOut->continueInx > 0) {
00342 genQueryInp.continueInx=genQueryOut->continueInx;
00343 rei->status = rsGenQuery(rsComm, &genQueryInp, &genQueryOut);
00344
00345 for (i=0;i<genQueryOut->rowCnt;i++) {
00346
00347
00348 tResult = genQueryOut->sqlResult[0].value;
00349 tResult += i*genQueryOut->sqlResult[0].len;
00350 snprintf(objPath, MAX_NAME_LEN, "%s/", tResult);
00351
00352
00353 tResult = genQueryOut->sqlResult[1].value;
00354 tResult += i*genQueryOut->sqlResult[1].len;
00355 strcat(objPath, tResult);
00356
00357
00358 getDataObjPSmeta(objPath, mybuf, rsComm);
00359 }
00360 }
00361 }
00362
00363
00364
00365 if (!mybuf->buf || !strlen((char*)mybuf->buf)) {
00366 appendStrToBBuf(mybuf, "");
00367 }
00368
00369
00370 fillBufLenInMsParam (outParam, strlen((char*)mybuf->buf), mybuf);
00371
00372 return 0;
00373 }
00374
00375
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
00410
00411
00412
00413 int
00414 msiGetDataObjAVUs(msParam_t *inpParam, msParam_t *outParam, ruleExecInfo_t *rei)
00415 {
00416 rsComm_t *rsComm;
00417 dataObjInp_t dataObjInp, *myDataObjInp;
00418 bytesBuf_t *mybuf;
00419
00420 genQueryInp_t genQueryInp;
00421 genQueryOut_t *genQueryOut;
00422 int i1a[10];
00423 int i1b[10];
00424 int i2a[10];
00425 char *condVal[10];
00426 char v1[MAX_NAME_LEN];
00427 char v2[MAX_NAME_LEN];
00428 char fullName[MAX_NAME_LEN];
00429 char myDirName[MAX_NAME_LEN];
00430 char myFileName[MAX_NAME_LEN];
00431 int printCount=0;
00432
00433 char *tags[]={"AVU", "attribute", "value", "units"};
00434
00435
00436 RE_TEST_MACRO (" Calling msiGetDataObjAVUs")
00437
00438 if (rei == NULL || rei->rsComm == NULL) {
00439 rodsLog (LOG_ERROR,
00440 "msiGetDataObjAVUs: input rei or rsComm is NULL");
00441 return (SYS_INTERNAL_NULL_INPUT_ERR);
00442 }
00443
00444 rsComm = rei->rsComm;
00445
00446
00447 rei->status = parseMspForDataObjInp (inpParam, &dataObjInp, &myDataObjInp, 0);
00448
00449 if (rei->status < 0) {
00450 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
00451 "msiGetDataObjAVUs: input inpParam1 error. status = %d", rei->status);
00452 return (rei->status);
00453 }
00454
00455
00456 memset (&genQueryInp, 0, sizeof (genQueryInp_t));
00457
00458 i1a[0]=COL_META_DATA_ATTR_NAME;
00459 i1b[0]=0;
00460 i1a[1]=COL_META_DATA_ATTR_VALUE;
00461 i1b[1]=0;
00462 i1a[2]=COL_META_DATA_ATTR_UNITS;
00463 i1b[2]=0;
00464 genQueryInp.selectInp.inx = i1a;
00465 genQueryInp.selectInp.value = i1b;
00466 genQueryInp.selectInp.len = 3;
00467
00468
00469 strncpy(fullName, myDataObjInp->objPath, MAX_NAME_LEN);
00470 rei->status = splitPathByKey(fullName, myDirName, myFileName, '/');
00471
00472 i2a[0]=COL_COLL_NAME;
00473 sprintf(v1,"='%s'",myDirName);
00474 condVal[0]=v1;
00475
00476 i2a[1]=COL_DATA_NAME;
00477 sprintf(v2,"='%s'",myFileName);
00478 condVal[1]=v2;
00479
00480
00481 genQueryInp.sqlCondInp.inx = i2a;
00482 genQueryInp.sqlCondInp.value = condVal;
00483 genQueryInp.sqlCondInp.len=2;
00484
00485 genQueryInp.maxRows=10;
00486 genQueryInp.continueInx=0;
00487 genQueryInp.condInput.len=0;
00488
00489
00490
00491 rei->status = rsGenQuery(rsComm, &genQueryInp, &genQueryOut);
00492
00493
00494
00495 mybuf = (bytesBuf_t *)malloc(sizeof(bytesBuf_t));
00496 memset (mybuf, 0, sizeof (bytesBuf_t));
00497
00498
00499
00500 appendStrToBBuf(mybuf, "<?xml version='1.0' encoding='utf-8'?>\n");
00501 appendStrToBBuf(mybuf, "<!-- Generated by iRODS (http://www.irods.org) -->\n");
00502 appendStrToBBuf(mybuf, "<metadata>\n");
00503
00504
00505 if (rei->status == CAT_NO_ROWS_FOUND) {
00506 i1a[0]=COL_D_DATA_PATH;
00507 genQueryInp.selectInp.len = 1;
00508 rei->status = rsGenQuery(rsComm, &genQueryInp, &genQueryOut);
00509 if (rei->status==0) {
00510
00511
00512 appendStrToBBuf(mybuf, "</metadata>\n");
00513 fillBufLenInMsParam (outParam, strlen((char*)mybuf->buf), mybuf);
00514 return (0);
00515
00516 }
00517 if (rei->status == CAT_NO_ROWS_FOUND) {
00518
00519 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
00520 "msiGetDataObjAVUs: DataObject %s not found. status = %d", fullName, rei->status);
00521 return (rei->status);
00522 }
00523 printCount+=genQueryOutToXML(genQueryOut, mybuf, tags);
00524 }
00525 else {
00526 printCount+=genQueryOutToXML(genQueryOut, mybuf, tags);
00527 }
00528
00529 while (rei->status==0 && genQueryOut->continueInx > 0) {
00530 genQueryInp.continueInx=genQueryOut->continueInx;
00531 rei->status = rsGenQuery(rsComm, &genQueryInp, &genQueryOut);
00532 printCount+= genQueryOutToXML(genQueryOut, mybuf, tags);
00533 }
00534
00535
00536 appendStrToBBuf(mybuf, "</metadata>\n");
00537
00538
00539 fillBufLenInMsParam (outParam, strlen((char*)mybuf->buf), mybuf);
00540
00541
00542 return (0);
00543
00544 }
00545
00546
00547
00548
00549
00550
00551
00552
00553
00554
00555
00556
00557
00558
00559
00560
00561
00562
00563
00564
00565
00566
00567
00568
00569
00570
00571
00572
00573
00574
00575
00576
00577
00578
00579
00580
00581
00582 int
00583 msiGetDataObjPSmeta(msParam_t *inpParam, msParam_t *outParam, ruleExecInfo_t *rei)
00584 {
00585 rsComm_t *rsComm;
00586 dataObjInp_t dataObjInp, *myDataObjInp;
00587 bytesBuf_t *mybuf;
00588
00589
00590 RE_TEST_MACRO (" Calling msiGetDataObjPSmeta")
00591
00592 if (rei == NULL || rei->rsComm == NULL) {
00593 rodsLog (LOG_ERROR,
00594 "msiGetDataObjPSmeta: input rei or rsComm is NULL");
00595 return (SYS_INTERNAL_NULL_INPUT_ERR);
00596 }
00597
00598 rsComm = rei->rsComm;
00599
00600
00601
00602 rei->status = parseMspForDataObjInp (inpParam, &dataObjInp, &myDataObjInp, 0);
00603
00604 if (rei->status < 0) {
00605 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
00606 "msiGetDataObjPSmeta: input inpParam1 error. status = %d", rei->status);
00607 return (rei->status);
00608 }
00609
00610
00611
00612 mybuf = (bytesBuf_t *)malloc(sizeof(bytesBuf_t));
00613 memset (mybuf, 0, sizeof (bytesBuf_t));
00614
00615
00616
00617 getDataObjPSmeta(myDataObjInp->objPath, mybuf, rsComm);
00618
00619
00620
00621 fillBufLenInMsParam (outParam, strlen((char*)mybuf->buf), mybuf);
00622
00623 return (rei->status);
00624
00625 }
00626
00627
00628
00629
00630
00631
00632
00633
00634
00635
00636
00637
00638
00639
00640
00641
00642
00643
00644
00645
00646
00647
00648
00649
00650
00651
00652
00653
00654
00655
00656
00657
00658
00659
00660
00661
00662
00663 int
00664 msiGetCollectionPSmeta(msParam_t *inpParam, msParam_t *outParam, ruleExecInfo_t *rei)
00665 {
00666 rsComm_t *rsComm;
00667 collInp_t collInpCache, *outCollInp;
00668 bytesBuf_t *mybuf;
00669
00670
00671 RE_TEST_MACRO (" Calling msiGetCollectionPSmeta")
00672
00673 if (rei == NULL || rei->rsComm == NULL) {
00674 rodsLog (LOG_ERROR,
00675 "msiGetCollectionPSmeta: input rei or rsComm is NULL");
00676 return (SYS_INTERNAL_NULL_INPUT_ERR);
00677 }
00678
00679 rsComm = rei->rsComm;
00680
00681
00682
00683 rei->status = parseMspForCollInp (inpParam, &collInpCache, &outCollInp, 0);
00684
00685 if (rei->status < 0) {
00686 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
00687 "msiGetCollectionPSmeta: input inpParam1 error. status = %d", rei->status);
00688 return (rei->status);
00689 }
00690
00691
00692
00693 mybuf = (bytesBuf_t *)malloc(sizeof(bytesBuf_t));
00694 memset (mybuf, 0, sizeof (bytesBuf_t));
00695
00696
00697
00698 getCollectionPSmeta(outCollInp->collName, mybuf, rsComm);
00699
00700
00701
00702 fillBufLenInMsParam (outParam, strlen((char*)mybuf->buf), mybuf);
00703
00704 return (rei->status);
00705
00706 }
00707
00708
00709
00710
00711
00712
00713
00714
00715
00716
00717
00718
00719
00720
00721
00722
00723
00724
00725
00726
00727
00728
00729
00730
00731
00732
00733
00734
00735
00736
00737
00738
00739
00740
00741
00742
00743
00744
00745
00746
00747
00748
00749
00750
00751
00752
00753
00754
00755
00756
00757
00758
00759
00760
00761 int
00762 msiLoadMetadataFromDataObj(msParam_t *inpParam, msParam_t *outParam, ruleExecInfo_t *rei)
00763 {
00764 dataObjInp_t dataObjInp, *myDataObjInp;
00765 rsComm_t *rsComm;
00766
00767
00768
00769 RE_TEST_MACRO (" Calling msiLoadMetadataFromDataObj")
00770
00771
00772
00773 if (rei == NULL || rei->rsComm == NULL) {
00774 rodsLog (LOG_ERROR, "msiLoadMetadataFromDataObj: input rei or rsComm is NULL.");
00775 return (SYS_INTERNAL_NULL_INPUT_ERR);
00776 }
00777
00778 rsComm = rei->rsComm;
00779
00780
00781 rei->status = parseMspForDataObjInp (inpParam, &dataObjInp, &myDataObjInp, 0);
00782 if (rei->status < 0) {
00783 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
00784 "msiLoadMetadataFromDataObj: input inpParam1 error. status = %d", rei->status);
00785 return (rei->status);
00786 }
00787
00788
00789
00790 rei->status = loadMetadataFromDataObj(myDataObjInp, rsComm);
00791
00792
00793 fillIntInMsParam(outParam, rei->status);
00794
00795 return (rei->status);
00796 }
00797
00798
00799
00800
00801
00802
00803
00804
00805
00806
00807
00808
00809
00810
00811
00812
00813
00814
00815
00816
00817
00818
00819
00820
00821
00822
00823
00824
00825
00826
00827
00828
00829
00830
00831
00832
00833
00834 int
00835 msiGetDataObjAIP(msParam_t *inpParam, msParam_t *outParam, ruleExecInfo_t *rei)
00836 {
00837 rsComm_t *rsComm;
00838 dataObjInp_t dataObjInp, *myDataObjInp;
00839 bytesBuf_t *mybuf;
00840
00841 genQueryInp_t genQueryInp;
00842 genQueryOut_t *genQueryOut;
00843 int i1a[30];
00844 int i1b[30];
00845 int i2a[30];
00846 char *condVal[30];
00847 char v1[MAX_NAME_LEN];
00848 char v2[MAX_NAME_LEN];
00849 char fullName[MAX_NAME_LEN];
00850 char myDirName[MAX_NAME_LEN];
00851 char myFileName[MAX_NAME_LEN];
00852 int printCount=0, i;
00853 char *tags[30];
00854
00855 char tmpStr[MAX_NAME_LEN];
00856 rodsObjStat_t *rodsObjStatOut;
00857
00858 RE_TEST_MACRO (" Calling GetDataObjAIP")
00859
00860 if (rei == NULL || rei->rsComm == NULL) {
00861 rodsLog (LOG_ERROR,
00862 "msiGetDataObjAIP: input rei or rsComm is NULL");
00863 return (SYS_INTERNAL_NULL_INPUT_ERR);
00864 }
00865
00866 rsComm = rei->rsComm;
00867
00868
00869 rei->status = parseMspForDataObjInp (inpParam, &dataObjInp, &myDataObjInp, 0);
00870
00871 if (rei->status < 0) {
00872 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
00873 "msiGetDataObjAIP: input inpParam1 error. status = %d", rei->status);
00874 return (rei->status);
00875 }
00876
00877
00878 strncpy(fullName, myDataObjInp->objPath, MAX_NAME_LEN);
00879 rei->status = splitPathByKey(fullName, myDirName, myFileName, '/');
00880
00881
00882
00883 mybuf = (bytesBuf_t *)malloc(sizeof(bytesBuf_t));
00884 memset (mybuf, 0, sizeof (bytesBuf_t));
00885
00886
00887
00888 appendStrToBBuf(mybuf, "<?xml version='1.0' encoding='utf-8'?>\n");
00889 appendStrToBBuf(mybuf, "<!-- Generated by SDSC iRODS (http://www.irods.org) -->\n");
00890 appendStrToBBuf(mybuf, "<AIP>\n");
00891
00892
00893
00894 tags[0]=strdup("");
00895 tags[1]=strdup("D_DATA_ID");
00896 tags[2]=strdup("D_COLL_ID");
00897 tags[3]=strdup("DATA_NAME");
00898 tags[4]=strdup("DATA_REPL_NUM");
00899 tags[5]=strdup("DATA_VERSION");
00900 tags[6]=strdup("DATA_TYPE_NAME");
00901 tags[7]=strdup("DATA_SIZE");
00902 tags[8]=strdup("D_RESC_GROUP_NAME");
00903 tags[9]=strdup("D_RESC_NAME");
00904 tags[10]=strdup("D_DATA_PATH");
00905 tags[11]=strdup("D_OWNER_NAME");
00906 tags[12]=strdup("D_OWNER_ZONE");
00907 tags[13]=strdup("D_REPL_STATUS");
00908 tags[14]=strdup("D_DATA_STATUS");
00909 tags[15]=strdup("D_DATA_CHECKSUM");
00910 tags[16]=strdup("D_EXPIRY");
00911 tags[17]=strdup("D_MAP_ID");
00912 tags[18]=strdup("D_COMMENTS");
00913 tags[19]=strdup("D_CREATE_TIME");
00914 tags[20]=strdup("D_MODIFY_TIME");
00915
00916
00917 memset (&genQueryInp, 0, sizeof (genQueryInp_t));
00918
00919 i1a[0]=COL_D_DATA_ID;
00920 i1a[1]=COL_D_COLL_ID;
00921 i1a[2]=COL_DATA_NAME;
00922 i1a[3]=COL_DATA_REPL_NUM;
00923 i1a[4]=COL_DATA_VERSION;
00924 i1a[5]=COL_DATA_TYPE_NAME;
00925 i1a[6]=COL_DATA_SIZE;
00926 i1a[7]=COL_D_RESC_GROUP_NAME;
00927 i1a[8]=COL_D_RESC_NAME;
00928 i1a[9]=COL_D_DATA_PATH;
00929 i1a[10]=COL_D_OWNER_NAME;
00930 i1a[11]=COL_D_OWNER_ZONE;
00931 i1a[12]=COL_D_REPL_STATUS;
00932 i1a[13]=COL_D_DATA_STATUS;
00933 i1a[14]=COL_D_DATA_CHECKSUM;
00934 i1a[15]=COL_D_EXPIRY;
00935 i1a[16]=COL_D_MAP_ID;
00936 i1a[17]=COL_D_COMMENTS;
00937 i1a[18]=COL_D_CREATE_TIME;
00938 i1a[19]=COL_D_MODIFY_TIME;
00939
00940 for (i=0; i<20; i++) {
00941 i1b[i]=0;
00942 }
00943
00944 genQueryInp.selectInp.inx = i1a;
00945 genQueryInp.selectInp.value = i1b;
00946 genQueryInp.selectInp.len = 20;
00947
00948
00949 i2a[0]=COL_COLL_NAME;
00950 sprintf(v1,"='%s'",myDirName);
00951 condVal[0]=v1;
00952
00953 i2a[1]=COL_DATA_NAME;
00954 sprintf(v2,"='%s'",myFileName);
00955 condVal[1]=v2;
00956
00957 genQueryInp.sqlCondInp.inx = i2a;
00958 genQueryInp.sqlCondInp.value = condVal;
00959 genQueryInp.sqlCondInp.len=2;
00960
00961 genQueryInp.maxRows=30;
00962 genQueryInp.continueInx=0;
00963 genQueryInp.condInput.len=0;
00964
00965
00966
00967 rei->status = rsGenQuery(rsComm, &genQueryInp, &genQueryOut);
00968
00969
00970
00971
00972
00973 if (rei->status == CAT_NO_ROWS_FOUND) {
00974 i1a[0]=COL_D_DATA_PATH;
00975 genQueryInp.selectInp.len = 1;
00976 rei->status = rsGenQuery(rsComm, &genQueryInp, &genQueryOut);
00977 if (rei->status==0) {
00978 printf("None\n");
00979 return(0);
00980 }
00981 if (rei->status == CAT_NO_ROWS_FOUND) {
00982
00983 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
00984 "msiGetDataObjAIP: DataObject %s not found. status = %d", fullName, rei->status);
00985 return (rei->status);
00986 }
00987 printCount+=genQueryOutToXML(genQueryOut, mybuf, tags);
00988 }
00989 else {
00990 printCount+=genQueryOutToXML(genQueryOut, mybuf, tags);
00991 }
00992
00993 while (rei->status==0 && genQueryOut->continueInx > 0) {
00994 genQueryInp.continueInx=genQueryOut->continueInx;
00995 rei->status = rsGenQuery(rsComm, &genQueryInp, &genQueryOut);
00996 printCount+= genQueryOutToXML(genQueryOut, mybuf, tags);
00997 }
00998
00999
01000
01001 tags[0]=strdup("AVU");
01002 tags[1]=strdup("attribute");
01003 tags[2]=strdup("value");
01004 tags[3]=strdup("units");
01005
01006 memset (&genQueryInp, 0, sizeof (genQueryInp_t));
01007
01008 i1a[0]=COL_META_DATA_ATTR_NAME;
01009 i1b[0]=0;
01010 i1a[1]=COL_META_DATA_ATTR_VALUE;
01011 i1b[1]=0;
01012 i1a[2]=COL_META_DATA_ATTR_UNITS;
01013 i1b[2]=0;
01014 genQueryInp.selectInp.inx = i1a;
01015 genQueryInp.selectInp.value = i1b;
01016 genQueryInp.selectInp.len = 3;
01017
01018
01019 strncpy(fullName, myDataObjInp->objPath, MAX_NAME_LEN);
01020 rei->status = splitPathByKey(fullName, myDirName, myFileName, '/');
01021
01022 i2a[0]=COL_COLL_NAME;
01023 sprintf(v1,"='%s'",myDirName);
01024 condVal[0]=v1;
01025
01026 i2a[1]=COL_DATA_NAME;
01027 sprintf(v2,"='%s'",myFileName);
01028 condVal[1]=v2;
01029
01030
01031 genQueryInp.sqlCondInp.inx = i2a;
01032 genQueryInp.sqlCondInp.value = condVal;
01033 genQueryInp.sqlCondInp.len=2;
01034
01035 genQueryInp.maxRows=10;
01036 genQueryInp.continueInx=0;
01037 genQueryInp.condInput.len=0;
01038
01039
01040 rei->status = rsGenQuery(rsComm, &genQueryInp, &genQueryOut);
01041
01042
01043 if (rei->status == CAT_NO_ROWS_FOUND) {
01044 i1a[0]=COL_D_DATA_PATH;
01045 genQueryInp.selectInp.len = 1;
01046 rei->status = rsGenQuery(rsComm, &genQueryInp, &genQueryOut);
01047 if (rei->status==0) {
01048 printf("None\n");
01049 return(0);
01050 }
01051 if (rei->status == CAT_NO_ROWS_FOUND) {
01052
01053 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
01054 "msiGetDataObjAVUs: DataObject %s not found. status = %d", fullName, rei->status);
01055 return (rei->status);
01056 }
01057 printCount+=genQueryOutToXML(genQueryOut, mybuf, tags);
01058 }
01059 else {
01060 printCount+=genQueryOutToXML(genQueryOut, mybuf, tags);
01061 }
01062
01063 while (rei->status==0 && genQueryOut->continueInx > 0) {
01064 genQueryInp.continueInx=genQueryOut->continueInx;
01065 rei->status = rsGenQuery(rsComm, &genQueryInp, &genQueryOut);
01066 printCount+= genQueryOutToXML(genQueryOut, mybuf, tags);
01067 }
01068
01069
01070 tags[0]=strdup("ACL");
01071 tags[1]=strdup("COL_DATA_ACCESS_TYPE");
01072 tags[2]=strdup("COL_DATA_ACCESS_NAME");
01073 tags[3]=strdup("COL_DATA_TOKEN_NAMESPACE");
01074 tags[4]=strdup("COL_DATA_ACCESS_USER_IDM");
01075 tags[5]=strdup("COL_DATA_ACCESS_DATA_ID");
01076
01077 memset (&genQueryInp, 0, sizeof (genQueryInp_t));
01078
01079 rei->status = rsObjStat(rsComm, &dataObjInp, &rodsObjStatOut);
01080
01081 addInxIval (&genQueryInp.selectInp, COL_USER_NAME, 1);
01082 addInxIval (&genQueryInp.selectInp, COL_DATA_ACCESS_NAME, 1);
01083
01084 snprintf (tmpStr, MAX_NAME_LEN, " = '%s'", rodsObjStatOut->dataId);
01085
01086 addInxVal (&genQueryInp.sqlCondInp, COL_DATA_ACCESS_DATA_ID, tmpStr);
01087
01088 snprintf (tmpStr, MAX_NAME_LEN, "='%s'", "access_type");
01089
01090
01091 addInxVal (&genQueryInp.sqlCondInp, COL_DATA_TOKEN_NAMESPACE, tmpStr);
01092
01093 genQueryInp.maxRows = MAX_SQL_ROWS;
01094
01095 rei->status = rsGenQuery (rsComm, &genQueryInp, &genQueryOut);
01096
01097
01098 if (rei->status == CAT_NO_ROWS_FOUND) {
01099 i1a[0]=COL_D_DATA_PATH;
01100 genQueryInp.selectInp.len = 1;
01101 rei->status = rsGenQuery(rsComm, &genQueryInp, &genQueryOut);
01102 if (rei->status==0) {
01103 printf("None\n");
01104 return(0);
01105 }
01106 if (rei->status == CAT_NO_ROWS_FOUND) {
01107
01108 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
01109 "msiGetDataObjAIP: DataObject %s not found. status = %d", fullName, rei->status);
01110 return (rei->status);
01111 }
01112 printCount+=genQueryOutToXML(genQueryOut, mybuf, tags);
01113 }
01114 else {
01115 printCount+=genQueryOutToXML(genQueryOut, mybuf, tags);
01116 }
01117
01118 while (rei->status==0 && genQueryOut->continueInx > 0) {
01119 genQueryInp.continueInx=genQueryOut->continueInx;
01120 rei->status = rsGenQuery(rsComm, &genQueryInp, &genQueryOut);
01121 printCount+= genQueryOutToXML(genQueryOut, mybuf, tags);
01122 }
01123
01124
01125
01126 appendStrToBBuf(mybuf, "</AIP>\n");
01127
01128
01129 fillBufLenInMsParam (outParam, strlen((char*)mybuf->buf), mybuf);
01130
01131 return (rei->status);
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
01169
01170
01171 int
01172 msiGetDataObjACL(msParam_t *inpParam, msParam_t *outParam, ruleExecInfo_t *rei)
01173 {
01174 rsComm_t *rsComm;
01175 dataObjInp_t dataObjInp, *myDataObjInp;
01176 bytesBuf_t *mybuf;
01177
01178
01179 RE_TEST_MACRO (" Calling msiGetDataObjACL")
01180
01181 if (rei == NULL || rei->rsComm == NULL) {
01182 rodsLog (LOG_ERROR, "msiGetDataObjACL: input rei or rsComm is NULL");
01183 return (SYS_INTERNAL_NULL_INPUT_ERR);
01184 }
01185
01186 rsComm = rei->rsComm;
01187
01188
01189 mybuf = (bytesBuf_t *)malloc(sizeof(bytesBuf_t));
01190 memset (mybuf, 0, sizeof (bytesBuf_t));
01191
01192
01193
01194 rei->status = parseMspForDataObjInp (inpParam, &dataObjInp, &myDataObjInp, 0);
01195
01196 if (rei->status < 0) {
01197 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
01198 "msiGetDataObjACL: input inpParam1 error. status = %d", rei->status);
01199 free(mybuf);
01200 return (rei->status);
01201 }
01202
01203
01204
01205 getDataObjACL(myDataObjInp, mybuf, rsComm);
01206
01207
01208
01209 fillBufLenInMsParam (outParam, strlen((char*)mybuf->buf), mybuf);
01210
01211 return (rei->status);
01212
01213 }
01214
01215
01216
01217
01218
01219
01220
01221
01222
01223
01224
01225
01226
01227
01228
01229
01230
01231
01232
01233
01234
01235
01236
01237
01238
01239
01240
01241
01242
01243
01244
01245
01246
01247
01248
01249
01250
01251
01252 int
01253 msiGetCollectionACL(msParam_t *inpParam1, msParam_t *inpParam2, msParam_t *outParam, ruleExecInfo_t *rei)
01254 {
01255 rsComm_t *rsComm;
01256 collInp_t collInpCache, *outCollInp;
01257 bytesBuf_t *mybuf;
01258
01259
01260 RE_TEST_MACRO (" Calling msiGetCollectionACL")
01261
01262 if (rei == NULL || rei->rsComm == NULL) {
01263 rodsLog (LOG_ERROR, "msiGetCollectionACL: input rei or rsComm is NULL");
01264 return (SYS_INTERNAL_NULL_INPUT_ERR);
01265 }
01266
01267 rsComm = rei->rsComm;
01268
01269
01270 mybuf = (bytesBuf_t *)malloc(sizeof(bytesBuf_t));
01271 memset (mybuf, 0, sizeof (bytesBuf_t));
01272
01273
01274 rei->status = parseMspForCollInp (inpParam1, &collInpCache, &outCollInp, 0);
01275
01276 if (rei->status < 0) {
01277 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
01278 "msiGetCollectionACL: input inpParam1 error. status = %d", rei->status);
01279 free(mybuf);
01280 return (rei->status);
01281 }
01282
01283
01284 rei->status = getCollectionACL(outCollInp, (char*)inpParam2->inOutStruct, mybuf, rsComm);
01285
01286
01287 if (rei->status < 0 || mybuf->buf == NULL)
01288 {
01289 rodsLog (LOG_ERROR, "msiGetCollectionACL: getCollectionACL error. Status = %d", rei->status);
01290 return (rei->status);
01291 }
01292
01293
01294 fillBufLenInMsParam (outParam, strlen((char*)mybuf->buf), mybuf);
01295 return (rei->status);
01296
01297 }
01298
01299
01300
01301
01302
01303
01304
01305
01306
01307
01308
01309
01310
01311
01312
01313
01314
01315
01316
01317
01318
01319
01320
01321
01322
01323
01324
01325
01326
01327
01328
01329
01330
01331
01332
01333
01334 int
01335 msiGetUserInfo(msParam_t *inpParam1, msParam_t *inpParam2, msParam_t *outParam, ruleExecInfo_t *rei)
01336 {
01337 rsComm_t *rsComm;
01338 char *userNameInp;
01339 bytesBuf_t *mybuf;
01340
01341
01342 RE_TEST_MACRO (" Calling msiGetUserInfo")
01343
01344 if (rei == NULL || rei->rsComm == NULL) {
01345 rodsLog (LOG_ERROR, "msiGetUserInfo: input rei or rsComm is NULL");
01346 return (SYS_INTERNAL_NULL_INPUT_ERR);
01347 }
01348
01349 rsComm = rei->rsComm;
01350
01351
01352 mybuf = (bytesBuf_t *)malloc(sizeof(bytesBuf_t));
01353 memset (mybuf, 0, sizeof (bytesBuf_t));
01354
01355
01356
01357 if ((userNameInp = parseMspForStr (inpParam1)) == NULL) {
01358 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
01359 "msiGetUserInfo: parseMspForStr error for param 1.");
01360 free(mybuf);
01361 return (rei->status);
01362 }
01363
01364
01365
01366 rei->status = getUserInfo(userNameInp, mybuf, rsComm);
01367
01368
01369 if (rei->status < 0) {
01370 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
01371 "msiGetUserInfo: getUserInfo failed for %s, status = %d", userNameInp, rei->status);
01372 }
01373
01374
01375
01376 fillIntInMsParam (outParam, rei->status);
01377
01378
01379 fillBufLenInMsParam (inpParam2, strlen((char*)mybuf->buf), mybuf);
01380
01381 return (rei->status);
01382
01383 }
01384
01385
01386
01387
01388
01389
01390
01391
01392
01393
01394
01395
01396
01397
01398
01399
01400
01401
01402
01403
01404
01405
01406
01407
01408
01409
01410
01411
01412
01413
01414
01415
01416
01417 int
01418 msiCreateUserAccountsFromDataObj(msParam_t *inpParam, msParam_t *outParam, ruleExecInfo_t *rei)
01419 {
01420 dataObjInp_t dataObjInp, *myDataObjInp;
01421 generalAdminInp_t generalAdminInp;
01422 rsComm_t *rsComm;
01423
01424
01425
01426 RE_TEST_MACRO (" Calling msiCreateUserAccountsFromDataObj")
01427
01428
01429
01430 if (rei == NULL || rei->rsComm == NULL) {
01431 rodsLog (LOG_ERROR, "msiCreateUserAccountsFromDataObj: input rei or rsComm is NULL.");
01432 return (SYS_INTERNAL_NULL_INPUT_ERR);
01433 }
01434
01435 rsComm = rei->rsComm;
01436
01437
01438 rei->status = parseMspForDataObjInp (inpParam, &dataObjInp, &myDataObjInp, 0);
01439 if (rei->status < 0) {
01440 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
01441 "msiCreateUserAccountsFromDataObj: input inpParam1 error. status = %d", rei->status);
01442 return (rei->status);
01443 }
01444
01445
01446
01447 memset (&generalAdminInp, 0, sizeof(generalAdminInp_t));
01448 generalAdminInp.arg0 = "add";
01449 generalAdminInp.arg1 = "user";
01450
01451
01452
01453 rei->status = genAdminOpFromDataObj(myDataObjInp, &generalAdminInp, rsComm);
01454
01455
01456 fillIntInMsParam(outParam, rei->status);
01457
01458 return (rei->status);
01459 }
01460
01461
01462
01463
01464
01465
01466
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 int
01496 msiLoadUserModsFromDataObj(msParam_t *inpParam, msParam_t *outParam, ruleExecInfo_t *rei)
01497 {
01498 dataObjInp_t dataObjInp, *myDataObjInp;
01499 generalAdminInp_t generalAdminInp;
01500 rsComm_t *rsComm;
01501
01502
01503
01504 RE_TEST_MACRO (" Calling msiLoadUserModsFromDataObj")
01505
01506
01507
01508 if (rei == NULL || rei->rsComm == NULL) {
01509 rodsLog (LOG_ERROR, "msiLoadUserModsFromDataObj: input rei or rsComm is NULL.");
01510 return (SYS_INTERNAL_NULL_INPUT_ERR);
01511 }
01512
01513 rsComm = rei->rsComm;
01514
01515
01516 rei->status = parseMspForDataObjInp (inpParam, &dataObjInp, &myDataObjInp, 0);
01517 if (rei->status < 0) {
01518 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
01519 "msiLoadUserModsFromDataObj: input inpParam1 error. status = %d", rei->status);
01520 return (rei->status);
01521 }
01522
01523
01524
01525 memset (&generalAdminInp, 0, sizeof(generalAdminInp_t));
01526 generalAdminInp.arg0 = "modify";
01527 generalAdminInp.arg1 = "user";
01528
01529
01530
01531 rei->status = genAdminOpFromDataObj(myDataObjInp, &generalAdminInp, rsComm);
01532
01533
01534 fillIntInMsParam(outParam, rei->status);
01535
01536 return (rei->status);
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
01572
01573 int
01574 msiDeleteUsersFromDataObj(msParam_t *inpParam, msParam_t *outParam, ruleExecInfo_t *rei)
01575 {
01576 dataObjInp_t dataObjInp, *myDataObjInp;
01577 generalAdminInp_t generalAdminInp;
01578 rsComm_t *rsComm;
01579
01580
01581
01582 RE_TEST_MACRO (" Calling msiDeleteUsersFromDataObj")
01583
01584
01585
01586 if (rei == NULL || rei->rsComm == NULL) {
01587 rodsLog (LOG_ERROR, "msiDeleteUsersFromDataObj: input rei or rsComm is NULL.");
01588 return (SYS_INTERNAL_NULL_INPUT_ERR);
01589 }
01590
01591 rsComm = rei->rsComm;
01592
01593
01594 rei->status = parseMspForDataObjInp (inpParam, &dataObjInp, &myDataObjInp, 0);
01595 if (rei->status < 0) {
01596 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
01597 "msiDeleteUsersFromDataObj: input inpParam error. status = %d", rei->status);
01598 return (rei->status);
01599 }
01600
01601
01602
01603 memset (&generalAdminInp, 0, sizeof(generalAdminInp_t));
01604 generalAdminInp.arg0 = "rm";
01605 generalAdminInp.arg1 = "user";
01606
01607
01608
01609 rei->status = genAdminOpFromDataObj(myDataObjInp, &generalAdminInp, rsComm);
01610
01611
01612 fillIntInMsParam(outParam, rei->status);
01613
01614 return (rei->status);
01615 }
01616
01617
01618
01619
01620
01621
01622
01623
01624
01625
01626
01627
01628
01629
01630
01631
01632
01633
01634
01635
01636
01637
01638
01639
01640
01641
01642
01643
01644
01645
01646
01647
01648
01649
01650
01651 int
01652 msiLoadACLFromDataObj(msParam_t *inpParam, msParam_t *outParam, ruleExecInfo_t *rei)
01653 {
01654 dataObjInp_t dataObjInp, *myDataObjInp;
01655 rsComm_t *rsComm;
01656
01657
01658
01659 RE_TEST_MACRO (" Calling msiLoadACLFromDataObj")
01660
01661
01662
01663 if (rei == NULL || rei->rsComm == NULL) {
01664 rodsLog (LOG_ERROR, "msiLoadACLFromDataObj: input rei or rsComm is NULL.");
01665 return (SYS_INTERNAL_NULL_INPUT_ERR);
01666 }
01667
01668 rsComm = rei->rsComm;
01669
01670
01671 rei->status = parseMspForDataObjInp (inpParam, &dataObjInp, &myDataObjInp, 0);
01672 if (rei->status < 0) {
01673 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
01674 "msiLoadACLFromDataObj: input inpParam error. status = %d", rei->status);
01675 return (rei->status);
01676 }
01677
01678
01679
01680 rei->status = loadACLFromDataObj(myDataObjInp, rsComm);
01681
01682
01683 fillIntInMsParam(outParam, rei->status);
01684
01685 return (rei->status);
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 int
01724 msiGetUserACL(msParam_t *inpParam1, msParam_t *inpParam2, msParam_t *outParam, ruleExecInfo_t *rei)
01725 {
01726 rsComm_t *rsComm;
01727 char *userNameInp;
01728 bytesBuf_t *mybuf;
01729
01730
01731 RE_TEST_MACRO (" Calling msiGetUserACL")
01732
01733 if (rei == NULL || rei->rsComm == NULL) {
01734 rodsLog (LOG_ERROR, "msiGetUserACL: input rei or rsComm is NULL");
01735 return (SYS_INTERNAL_NULL_INPUT_ERR);
01736 }
01737
01738 rsComm = rei->rsComm;
01739
01740
01741 mybuf = (bytesBuf_t *)malloc(sizeof(bytesBuf_t));
01742 memset (mybuf, 0, sizeof (bytesBuf_t));
01743
01744
01745
01746 if ((userNameInp = parseMspForStr (inpParam1)) == NULL) {
01747 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
01748 "msiGetUserACL: parseMspForStr error for param 1.");
01749 free(mybuf);
01750 return (rei->status);
01751 }
01752
01753
01754
01755 rei->status = getUserACL(userNameInp, mybuf, rsComm);
01756
01757
01758 if (rei->status < 0) {
01759 rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, rei->status,
01760 "msiGetUserACL: getUserACL failed for %s, status = %d", userNameInp, rei->status);
01761 }
01762
01763
01764
01765 fillIntInMsParam (outParam, rei->status);
01766
01767
01768 fillBufLenInMsParam (inpParam2, strlen((char*)mybuf->buf), mybuf);
01769
01770 return (rei->status);
01771
01772 }
01773
01774
01775
01776
01777
01778
01779
01780
01781
01782
01783
01784
01785
01786
01787
01788
01789
01790
01791
01792
01793
01794
01795
01796
01797
01798
01799
01800
01801
01802
01803
01804
01805
01806
01807
01808
01809
01810 int
01811 msiSetDataType(msParam_t *inpParam1, msParam_t *inpParam2, msParam_t *inpParam3, msParam_t *outParam, ruleExecInfo_t *rei)
01812 {
01813 char *dataTypeStr, *dataIdStr;
01814 dataObjInp_t dataObjInp, *myDataObjInp;
01815
01816 modDataObjMeta_t modDataObjMetaInp;
01817 dataObjInfo_t dataObjInfo;
01818 keyValPair_t regParam;
01819
01820
01821 RE_TEST_MACRO (" Calling msiSetDataType")
01822
01823 if (rei == NULL || rei->rsComm == NULL) {
01824 rodsLog (LOG_ERROR, "msiSetDataType: input rei or rsComm is NULL.");
01825 return (SYS_INTERNAL_NULL_INPUT_ERR);
01826 }
01827
01828
01829
01830 memset (&dataObjInfo, 0, sizeof (dataObjInfo_t));
01831 memset (®Param, 0, sizeof (keyValPair_t));
01832
01833
01834
01835 if ((dataIdStr = parseMspForStr(inpParam1)) != NULL) {
01836 dataObjInfo.dataId = (rodsLong_t) atoll(dataIdStr);
01837 }
01838
01839
01840
01841 if ( parseMspForDataObjInp (inpParam2, &dataObjInp, &myDataObjInp, 0) >= 0) {
01842 strncpy(dataObjInfo.objPath, dataObjInp.objPath, MAX_NAME_LEN);
01843 }
01844
01845
01846
01847 if (!(dataIdStr || dataObjInfo.objPath)) {
01848 rodsLog (LOG_ERROR, "msiSetDataType: No data object ID or path provided.");
01849 return (USER__NULL_INPUT_ERR);
01850 }
01851
01852
01853
01854 if ((dataTypeStr = parseMspForStr (inpParam3)) == NULL) {
01855 rodsLog (LOG_ERROR, "msiSetDataType: parseMspForStr error for param 3.");
01856 return (USER__NULL_INPUT_ERR);
01857 }
01858 addKeyVal (®Param, DATA_TYPE_KW, dataTypeStr);
01859
01860
01861
01862 modDataObjMetaInp.dataObjInfo = &dataObjInfo;
01863 modDataObjMetaInp.regParam = ®Param;
01864 rei->status = rsModDataObjMeta (rei->rsComm, &modDataObjMetaInp);
01865
01866
01867
01868 if (rei->status < 0) {
01869 if (dataObjInfo.objPath) {
01870 rodsLog (LOG_ERROR, "msiSetDataType: rsModDataObjMeta failed for object %s, status = %d", dataObjInfo.objPath, rei->status);
01871 }
01872 else {
01873 rodsLog (LOG_ERROR, "msiSetDataType: rsModDataObjMeta failed for object ID %d, status = %d", dataObjInfo.dataId, rei->status);
01874 }
01875 }
01876
01877
01878
01879 fillIntInMsParam (outParam, rei->status);
01880
01881 return (rei->status);
01882
01883 }
01884
01885
01886
01887
01888
01889
01890
01891
01892
01893
01894
01895
01896
01897
01898
01899
01900
01901
01902
01903
01904
01905
01906
01907
01908
01909
01910
01911
01912
01913
01914
01915
01916
01917
01918
01919
01920 int
01921 msiGuessDataType(msParam_t *inpParam1, msParam_t *inpParam2, msParam_t *outParam, ruleExecInfo_t *rei)
01922 {
01923 char *pathStr, *extStr;
01924 dataObjInp_t dataObjInp, *myDataObjInp;
01925
01926 genQueryInp_t genQueryInp;
01927 char condStr[MAX_NAME_LEN];
01928 genQueryOut_t *genQueryOut;
01929 sqlResult_t *sqlResult;
01930
01931
01932 RE_TEST_MACRO (" Calling msiGuessDataType")
01933
01934 if (rei == NULL || rei->rsComm == NULL) {
01935 rodsLog (LOG_ERROR, "msiGuessDataType: input rei or rsComm is NULL.");
01936 return (SYS_INTERNAL_NULL_INPUT_ERR);
01937 }
01938
01939
01940
01941 rei->status = parseMspForDataObjInp (inpParam1, &dataObjInp, &myDataObjInp, 0);
01942 if (rei->status < 0) {
01943 rodsLog (LOG_ERROR, "msiGuessDataType: No data object path provided.");
01944 return (rei->status);
01945 }
01946 pathStr = dataObjInp.objPath;
01947
01948
01949
01950 extStr = strrchr(pathStr, '.');
01951 if (!extStr) {
01952 fillStrInMsParam (inpParam2, "generic");
01953 fillIntInMsParam (outParam, 0);
01954 return (0);
01955 }
01956
01957
01958
01959 memset (&genQueryInp, 0, sizeof (genQueryInp_t));
01960 genQueryInp.maxRows = MAX_SQL_ROWS;
01961
01962
01963 addInxIval (&genQueryInp.selectInp, COL_TOKEN_NAME, 1);
01964 addInxIval (&genQueryInp.selectInp, COL_TOKEN_ID, ORDER_BY);
01965
01966
01967 snprintf (condStr, MAX_NAME_LEN, " like '%%|%s|%%'", extStr);
01968 addInxVal (&genQueryInp.sqlCondInp, COL_TOKEN_VALUE2, condStr);
01969
01970
01971
01972 rei->status = rsGenQuery (rei->rsComm, &genQueryInp, &genQueryOut);
01973
01974
01975
01976 if (rei->status == CAT_NO_ROWS_FOUND) {
01977 fillStrInMsParam (inpParam2, "generic");
01978 fillIntInMsParam (outParam, rei->status);
01979 return (0);
01980 }
01981
01982
01983
01984 if (rei->status < 0) {
01985 rodsLog (LOG_ERROR, "msiGuessDataType: rsGenQuery failed for object %s, status = %d", pathStr, rei->status);
01986 }
01987
01988
01989
01990 sqlResult = getSqlResultByInx(genQueryOut, COL_TOKEN_NAME);
01991 fillStrInMsParam (inpParam2, sqlResult->value);
01992
01993
01994
01995 genQueryInp.maxRows = -1;
01996 genQueryInp.continueInx=genQueryOut->continueInx;
01997 rsGenQuery (rei->rsComm, &genQueryInp, &genQueryOut);
01998
01999
02000
02001 fillIntInMsParam (outParam, rei->status);
02002
02003 return (rei->status);
02004
02005 }
02006
02007
02008
02009
02010
02011
02012
02013
02014
02015
02016
02017
02018
02019
02020
02021
02022
02023
02024
02025
02026
02027
02028
02029
02030
02031
02032
02033
02034
02035
02036
02037
02038
02039
02040
02041
02042
02043
02044
02045
02046
02047
02048
02049
02050
02051
02052
02053
02054
02055
02056
02057
02058 int
02059 msiMergeDataCopies(msParam_t *objPath, msParam_t *currentColl, msParam_t *masterColl, msParam_t *status, ruleExecInfo_t *rei)
02060 {
02061 dataObjInp_t currentObjInpCache, *currentObjInp;
02062 dataObjInp_t masterObjInp;
02063 collInp_t currentCollInpCache, *currentCollInp;
02064 collInp_t masterCollInpCache, *masterCollInp;
02065 dataObjCopyInp_t dataObjRenameInp;
02066
02067 execCmd_t execCmdInp;
02068 execCmdOut_t *execCmdOut = NULL;
02069
02070 char tmpPath[MAX_NAME_LEN], *tmpPtr;
02071
02072 collInp_t collCreateInp;
02073
02074 dataObjInfo_t *currentDataObjInfo = NULL;
02075 dataObjInfo_t *masterDataObjInfo = NULL;
02076
02077 regReplica_t regReplicaInp;
02078
02079 rodsLong_t masterObjId = -1;
02080 char *objChksm = NULL, *masterChksm = NULL;
02081
02082 modAVUMetadataInp_t modAVUMetadataInp;
02083
02084
02085
02086
02087
02088 RE_TEST_MACRO (" Calling msiMergeDataCopies")
02089
02090
02091
02092 if (rei == NULL || rei->rsComm == NULL) {
02093 rodsLog (LOG_ERROR, "msiMergeDataCopies: input rei or rsComm is NULL.");
02094 return (SYS_INTERNAL_NULL_INPUT_ERR);
02095 }
02096
02097
02098
02099
02100
02101 rei->status = parseMspForDataObjInp (objPath, ¤tObjInpCache, ¤tObjInp, 0);
02102 if (rei->status < 0) {
02103 rodsLog (LOG_ERROR, "msiMergeDataCopies: input objPath error. status = %d", rei->status);
02104 return (rei->status);
02105 }
02106
02107
02108
02109 rei->status = parseMspForCollInp (currentColl, ¤tCollInpCache, ¤tCollInp, 0);
02110 if (rei->status < 0) {
02111 rodsLog (LOG_ERROR, "msiMergeDataCopies: input currentColl error. status = %d", rei->status);
02112 return (rei->status);
02113 }
02114
02115
02116
02117 rei->status = parseMspForCollInp (masterColl, &masterCollInpCache, &masterCollInp, 0);
02118 if (rei->status < 0) {
02119 rodsLog (LOG_ERROR, "msiMergeDataCopies: input masterColl error. status = %d", rei->status);
02120 return (rei->status);
02121 }
02122
02123
02124
02125 if (!strlen(currentObjInp->objPath) || !strlen(currentCollInp->collName) || !strlen(masterCollInp->collName) )
02126 {
02127 rei->status = USER__NULL_INPUT_ERR;
02128 rodsLog (LOG_ERROR, "msiMergeDataCopies: Missing input. status = %d", rei->status);
02129 return (rei->status);
02130 }
02131
02132
02133
02134
02135
02136 memset (&masterObjInp, 0, sizeof(dataObjInp_t));
02137 snprintf(masterObjInp.objPath, MAX_NAME_LEN, "%s/%s", masterCollInp->collName,
02138 currentObjInp->objPath + strlen(currentCollInp->collName) + 1);
02139
02140
02141 rei->status = isData (rei->rsComm, masterObjInp.objPath, &masterObjId);
02142
02143
02144 if (masterObjId <= 0)
02145 {
02146
02147 memset (&collCreateInp, 0, sizeof(collInp_t));
02148 addKeyVal (&collCreateInp.condInput, RECURSIVE_OPR__KW, "");
02149
02150
02151 strncpy (collCreateInp.collName, masterObjInp.objPath, MAX_NAME_LEN-1);
02152 tmpPtr = strrchr(collCreateInp.collName, '/');
02153 *tmpPtr = '\0';
02154
02155
02156 rei->status = rsCollCreate (rei->rsComm, &collCreateInp);
02157 if (rei->status < 0) {
02158 rodsLog (LOG_ERROR, "msiMergeDataCopies: rsCollCreate error. status = %d", rei->status);
02159 return (rei->status);
02160 }
02161
02162
02163
02164 memset (&dataObjRenameInp, 0, sizeof(dataObjCopyInp_t));
02165 strncpy (dataObjRenameInp.srcDataObjInp.objPath, currentObjInp->objPath, MAX_NAME_LEN-1);
02166 strncpy (dataObjRenameInp.destDataObjInp.objPath, masterObjInp.objPath, MAX_NAME_LEN-1);
02167
02168
02169 rei->status = rsDataObjRename (rei->rsComm, &dataObjRenameInp);
02170
02171
02172 fillIntInMsParam (status, rei->status);
02173 return (rei->status);
02174 }
02175
02176
02177
02178
02179
02180 rei->status = rsDataObjChksum (rei->rsComm, currentObjInp, &objChksm);
02181
02182
02183 rei->status = rsDataObjChksum (rei->rsComm, &masterObjInp, &masterChksm);
02184
02185
02186 if ( !(objChksm && strlen(objChksm) && masterChksm && strlen(masterChksm)) )
02187 {
02188 rei->status = USER_CHKSUM_MISMATCH;
02189 rodsLog (LOG_ERROR, "msiMergeDataCopies: Missing checksum(s). status = %d", rei->status);
02190 return (rei->status);
02191 }
02192
02193
02194
02195 if (!strcmp(masterChksm, objChksm))
02196 {
02197
02198 rei->status = getDataObjInfo(rei->rsComm, currentObjInp, ¤tDataObjInfo, ACCESS_READ_OBJECT, 0);
02199 rei->status = getDataObjInfo(rei->rsComm, &masterObjInp, &masterDataObjInfo, ACCESS_READ_OBJECT, 0);
02200
02201 if( currentDataObjInfo != NULL ) {
02202
02203
02204 snprintf(tmpPath, MAX_NAME_LEN, "%s/%s", currentDataObjInfo->rescInfo->rescVaultPath,
02205 masterObjInp.objPath + strlen(currentDataObjInfo->rescInfo->zoneName) + 2);
02206
02207
02208 tmpPtr = &tmpPath[strlen(tmpPath)-1];
02209 while (*tmpPtr != '/' && tmpPtr > tmpPath)
02210 {
02211 tmpPtr--;
02212 }
02213 *tmpPtr = '\0';
02214
02215
02216
02217 memset(&execCmdInp, 0, sizeof(execCmd_t));
02218 rstrcpy(execCmdInp.execAddr, currentDataObjInfo->rescInfo->rescLoc, LONG_NAME_LEN);
02219 rstrcpy(execCmdInp.cmd, "mkdir", LONG_NAME_LEN);
02220 snprintf(execCmdInp.cmdArgv, MAX_NAME_LEN, "-p \"%s\"", tmpPath);
02221
02222
02223
02224 rei->status = rsExecCmd (rei->rsComm, &execCmdInp, &execCmdOut);
02225
02226 if (rei->status < 0) {
02227 rodsLog (LOG_ERROR, "msiMergeDataCopies: rsExecCmd failed for %s %s. status = %d",
02228 execCmdInp.cmd, execCmdInp.cmdArgv, rei->status);
02229 return (rei->status);
02230 }
02231
02232
02233
02234 *tmpPtr = '/';
02235
02236
02237 memset(&execCmdInp, 0, sizeof(execCmd_t));
02238 rstrcpy(execCmdInp.execAddr, currentDataObjInfo->rescInfo->rescLoc, LONG_NAME_LEN);
02239 rstrcpy(execCmdInp.cmd, "ln", LONG_NAME_LEN);
02240 snprintf(execCmdInp.cmdArgv, MAX_NAME_LEN, "\"%s\" \"%s\"", currentDataObjInfo->filePath, tmpPath);
02241
02242
02243
02244 rei->status = rsExecCmd (rei->rsComm, &execCmdInp, &execCmdOut);
02245
02246 if (rei->status < 0) {
02247 rodsLog (LOG_ERROR, "msiMergeDataCopies: rsExecCmd failed for %s %s. status = %d",
02248 execCmdInp.cmd, execCmdInp.cmdArgv, rei->status);
02249 return (rei->status);
02250 }
02251
02252
02253
02254
02255
02256 rstrcpy(currentDataObjInfo->filePath, tmpPath, MAX_NAME_LEN);
02257 rstrcpy(currentDataObjInfo->objPath, masterObjInp.objPath, MAX_NAME_LEN);
02258
02259
02260
02261 memset(®ReplicaInp, 0, sizeof(regReplica_t));
02262 regReplicaInp.srcDataObjInfo = masterDataObjInfo;
02263 regReplicaInp.destDataObjInfo = currentDataObjInfo;
02264
02265
02266
02267 rei->status = rsRegReplica (rei->rsComm, ®ReplicaInp);
02268
02269 if (rei->status < 0) {
02270 rodsLog (LOG_ERROR, "msiMergeDataCopies: rsRegReplica failed for %s. status = %d",
02271 currentDataObjInfo->filePath, rei->status);
02272 return (rei->status);
02273 }
02274
02275
02276
02277 addKeyVal (¤tObjInp->condInput, FORCE_FLAG_KW, "");
02278 rei->status = rsDataObjUnlink (rei->rsComm, currentObjInp);
02279
02280 if (rei->status < 0) {
02281 rodsLog (LOG_ERROR, "msiMergeDataCopies: rsDataObjUnlink failed for %s. status = %d",
02282 currentObjInp->objPath, rei->status);
02283 return (rei->status);
02284 }
02285
02286
02287
02288 fillIntInMsParam (status, rei->status);
02289 return (rei->status);
02290
02291 }
02292 }
02293
02294
02295
02296
02297
02298 memset (&modAVUMetadataInp, 0, sizeof(modAVUMetadataInp_t));
02299 modAVUMetadataInp.arg0 = "add";
02300 modAVUMetadataInp.arg1 = "-d";
02301 modAVUMetadataInp.arg2 = currentObjInp->objPath;
02302 modAVUMetadataInp.arg3 = "CHECKSUM_MISMATCH";
02303 modAVUMetadataInp.arg4 = masterChksm;
02304 modAVUMetadataInp.arg5 = NULL;
02305
02306
02307 rei->status = rsModAVUMetadata (rei->rsComm, &modAVUMetadataInp);
02308
02309 if (rei->status < 0) {
02310 rodsLog (LOG_ERROR, "msiMergeDataCopies: rsModAVUMetadata failed for %s. status = %d",
02311 currentObjInp->objPath, rei->status);
02312 }
02313
02314
02315
02316
02317
02318 fillIntInMsParam (status, rei->status);
02319
02320
02321 return (rei->status);
02322 }
02323
02324
02325
02326
02327
02328
02329
02330
02331
02332
02333
02334
02335
02336
02337
02338
02339
02340
02341
02342
02343
02344
02345
02346
02347
02348
02349
02350
02351
02352
02353
02354
02355
02356
02357
02358
02359
02360
02361
02362 int
02363 msiFlagDataObjwithAVU(msParam_t *dataObj, msParam_t *flag, msParam_t *status, ruleExecInfo_t *rei)
02364 {
02365
02366 dataObjInp_t dataObjInp, *myDataObjInp;
02367 char *flagStr;
02368
02369
02370 modAVUMetadataInp_t modAVUMetadataInp;
02371
02372
02373
02374
02375
02376 RE_TEST_MACRO (" Calling msiFlagDataObjWithAVU")
02377
02378
02379
02380 if (rei == NULL || rei->rsComm == NULL)
02381 {
02382 rodsLog (LOG_ERROR, "msiFlagDataObjWithAVU: input rei or rsComm is NULL.");
02383 return (SYS_INTERNAL_NULL_INPUT_ERR);
02384 }
02385
02386
02387
02388
02389
02390 rei->status = parseMspForDataObjInp (dataObj, &dataObjInp, &myDataObjInp, 0);
02391 if (rei->status < 0)
02392 {
02393 rodsLog (LOG_ERROR, "msiFlagDataObjWithAVU: input dataObj error. status = %d", rei->status);
02394 return (rei->status);
02395 }
02396
02397
02398 flagStr = parseMspForStr(flag);
02399 if (!flagStr || !strlen(flagStr))
02400 {
02401 rodsLog (LOG_ERROR, "msiFlagDataObjWithAVU: flag string is empty or NULL.");
02402 return (USER__NULL_INPUT_ERR);
02403 }
02404
02405
02406
02407
02408
02409 memset (&modAVUMetadataInp, 0, sizeof(modAVUMetadataInp_t));
02410 modAVUMetadataInp.arg0 = "add";
02411 modAVUMetadataInp.arg1 = "-d";
02412 modAVUMetadataInp.arg2 = myDataObjInp->objPath;
02413 modAVUMetadataInp.arg3 = flagStr;
02414 modAVUMetadataInp.arg4 = "1";
02415 modAVUMetadataInp.arg5 = NULL;
02416
02417
02418 rei->status = rsModAVUMetadata (rei->rsComm, &modAVUMetadataInp);
02419
02420
02421
02422
02423
02424 fillIntInMsParam (status, rei->status);
02425 return (rei->status);
02426 }
02427
02428
02429
02430
02431
02432
02433
02434
02435
02436
02437
02438
02439
02440
02441
02442
02443
02444
02445
02446
02447
02448
02449
02450
02451
02452
02453
02454
02455
02456
02457
02458
02459
02460
02461
02462
02463
02464
02465
02466
02467
02468 int
02469 msiFlagInfectedObjs(msParam_t *scanResObj, msParam_t *scanResc, msParam_t *status, ruleExecInfo_t *rei)
02470 {
02471
02472 dataObjInp_t dataObjInpCache, *dataObjInp;
02473 openStat_t *openStat;
02474 char *resource;
02475
02476
02477 openedDataObjInp_t dataObjReadInp;
02478 bytesBuf_t *readBuf = NULL;
02479 int objID;
02480
02481
02482 modAVUMetadataInp_t modAVUMetadataInp;
02483 char infectedObjPath[MAX_NAME_LEN];
02484 char infectedFlag[NAME_LEN];
02485
02486
02487 char *lineStart, *lineEnd, *colon;
02488
02489
02490 char tStr0[TIME_LEN], tStr[TIME_LEN];
02491
02492
02493
02494
02495
02496 RE_TEST_MACRO (" Calling msiFlagInfectedObjs")
02497
02498
02499
02500 if (rei == NULL || rei->rsComm == NULL)
02501 {
02502 rodsLog (LOG_ERROR, "msiFlagInfectedObjs: input rei or rsComm is NULL.");
02503 return (SYS_INTERNAL_NULL_INPUT_ERR);
02504 }
02505
02506
02507
02508
02509
02510 rei->status = parseMspForDataObjInp (scanResObj, &dataObjInpCache, &dataObjInp, 0);
02511 if (rei->status < 0)
02512 {
02513 rodsLog (LOG_ERROR, "msiFlagInfectedObjs: input dataObj error. status = %d", rei->status);
02514 return (rei->status);
02515 }
02516
02517
02518 resource = parseMspForStr(scanResc);
02519 if (!resource || !strlen(resource))
02520 {
02521 rodsLog (LOG_ERROR, "msiFlagInfectedObjs: resource string is empty or NULL.");
02522 return (USER__NULL_INPUT_ERR);
02523 }
02524
02525
02526
02527
02528
02529 objID = rsDataObjOpenAndStat(rei->rsComm, dataObjInp, &openStat);
02530 if (objID < 0)
02531 {
02532 rodsLog (LOG_ERROR, "msiFlagInfectedObjs: Could not open scan result object. status = %d", objID);
02533 return (objID);
02534 }
02535
02536
02537 if (openStat->dataSize > 5*1024*1024)
02538 {
02539 rodsLog (LOG_ERROR, "msiFlagInfectedObjs: Scan result object should be much smaller than 5MB. status = %d", USER_FILE_TOO_LARGE);
02540 return (USER_FILE_TOO_LARGE);
02541 }
02542
02543
02544 memset (&dataObjReadInp, 0, sizeof (dataObjReadInp));
02545 dataObjReadInp.l1descInx = objID;
02546 dataObjReadInp.len = openStat->dataSize;
02547
02548
02549 readBuf = (bytesBuf_t *) malloc (sizeof (bytesBuf_t));
02550 memset (readBuf, 0, sizeof (bytesBuf_t));
02551
02552
02553 rei->status = rsDataObjRead (rei->rsComm, &dataObjReadInp, readBuf);
02554 if (rei->status < 0)
02555 {
02556 rodsLog (LOG_ERROR, "msiFlagInfectedObjs: Could not read scan result object. status = %d", rei->status);
02557 return (rei->status);
02558 }
02559
02560
02561 rei->status = rsDataObjClose (rei->rsComm, &dataObjReadInp);
02562
02563
02564
02565
02566
02567 getNowStr(tStr0);
02568 getLocalTimeFromRodsTime(tStr0,tStr);
02569 snprintf(infectedFlag, NAME_LEN, "%s.%s", "VIRUS_SCAN_FAILED", tStr);
02570
02571
02572 appendStrToBBuf(readBuf, "");
02573
02574
02575 lineStart = (char*)readBuf->buf;
02576
02577 while ( (lineEnd=strstr(lineStart, "\n")) )
02578 {
02579
02580 lineEnd[0]='\0';
02581
02582
02583 colon = strstr(lineStart, ":");
02584 if (!colon)
02585 {
02586 break;
02587 }
02588
02589
02590 colon[0]='\0';
02591
02592
02593 rei->status = getObjectByFilePath(lineStart, resource, infectedObjPath, rei->rsComm);
02594 if (rei->status < 0)
02595 {
02596 rodsLog (LOG_ERROR, "msiFlagInfectedObjs: getObjectByFilePath error for %s. status = %d",
02597 lineStart, rei->status);
02598 return (rei->status);
02599 }
02600
02601
02602 memset (&modAVUMetadataInp, 0, sizeof(modAVUMetadataInp_t));
02603 modAVUMetadataInp.arg0 = "add";
02604 modAVUMetadataInp.arg1 = "-d";
02605 modAVUMetadataInp.arg2 = infectedObjPath;
02606 modAVUMetadataInp.arg3 = infectedFlag;
02607 modAVUMetadataInp.arg4 = colon+2;
02608 modAVUMetadataInp.arg5 = NULL;
02609
02610
02611 rei->status = rsModAVUMetadata (rei->rsComm, &modAVUMetadataInp);
02612
02613
02614 lineStart=lineEnd+1;
02615 }
02616
02617
02618
02619
02620
02621 fillIntInMsParam (status, rei->status);
02622 return (rei->status);
02623
02624 }
02625
02626
02627
02628
02629
02630
02631
02632
02633
02634
02635
02636
02637
02638
02639
02640
02641
02642
02643
02644
02645
02646
02647
02648
02649
02650
02651
02652
02653
02654
02655
02656
02657
02658
02659
02660
02661
02662
02663
02664
02665 int
02666 msiStripAVUs(msParam_t *target, msParam_t *options, msParam_t *status, ruleExecInfo_t *rei)
02667 {
02668
02669 dataObjInp_t dataObjInpCache, *dataObjInp;
02670
02671
02672 modAVUMetadataInp_t modAVUMetadataInp;
02673
02674
02675 RE_TEST_MACRO (" Calling msiStripAVUs")
02676
02677
02678
02679 memset (&modAVUMetadataInp, 0, sizeof(modAVUMetadataInp_t));
02680 modAVUMetadataInp.arg0 = "rmw";
02681 modAVUMetadataInp.arg3 = "%";
02682 modAVUMetadataInp.arg4 = "%";
02683 modAVUMetadataInp.arg5 = "%";
02684
02685
02686 if (1)
02687 {
02688 rei->status = parseMspForDataObjInp (target, &dataObjInpCache, &dataObjInp, 0);
02689 if (rei->status < 0)
02690 {
02691 rodsLog (LOG_ERROR, "msiStripAVUs: input target error. status = %d", rei->status);
02692 return (rei->status);
02693 }
02694
02695
02696 modAVUMetadataInp.arg1 = "-d";
02697 modAVUMetadataInp.arg2 = dataObjInp->objPath;
02698 }
02699
02700
02701 rei->status = rsModAVUMetadata (rei->rsComm, &modAVUMetadataInp);
02702
02703
02704 if (rei->status == CAT_SUCCESS_BUT_WITH_NO_INFO)
02705 {
02706 rei->status = 0;
02707 }
02708
02709
02710 fillIntInMsParam (status, rei->status);
02711 return (rei->status);
02712 }
02713
02714
02715
02716
02717
02718