00001
00002
00003
00004
00005
00006 #include "integrityChecksMS.h"
00007 #include "icutils.h"
00008
00009
00010
00011
00012
00013
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 int
00050 msiVerifyOwner (msParam_t* collinp, msParam_t* ownerinp, msParam_t* bufout, msParam_t* statout, ruleExecInfo_t *rei)
00051 {
00052
00053 genQueryInp_t genQueryInp;
00054 genQueryOut_t *genQueryOut = NULL;
00055 char condStr[MAX_NAME_LEN];
00056 rsComm_t *rsComm = NULL;
00057 char* collname = NULL;
00058 char* ownerlist = NULL;
00059 int i,j;
00060 sqlResult_t *dataName;
00061 sqlResult_t *dataOwner;
00062 char delims[]=",";
00063 char* word = NULL;
00064 char** olist=NULL;
00065 bytesBuf_t* stuff=NULL;
00066
00067 RE_TEST_MACRO (" Calling msiVerifyOwner")
00068
00069
00070 if (rei == NULL || rei->rsComm == NULL) {
00071 rodsLog (LOG_ERROR, "msiVerifyOwner: input rei or rsComm is NULL");
00072 return (SYS_INTERNAL_NULL_INPUT_ERR);
00073 }
00074
00075 rsComm = rei->rsComm;
00076
00077 memset (&genQueryInp, 0, sizeof(genQueryInp_t));
00078 genQueryInp.maxRows = MAX_SQL_ROWS;
00079
00080
00081 stuff = (bytesBuf_t *)malloc(sizeof(bytesBuf_t));
00082 memset (stuff, 0, sizeof (bytesBuf_t));
00083
00084
00085 collname = strdup ((char*)collinp->inOutStruct);
00086
00087
00088 addInxIval (&genQueryInp.selectInp, COL_DATA_NAME, 1);
00089 addInxIval (&genQueryInp.selectInp, COL_D_OWNER_NAME, 1);
00090 snprintf (condStr, MAX_NAME_LEN, " = '%s'", collname);
00091 addInxVal (&genQueryInp.sqlCondInp, COL_COLL_NAME, condStr);
00092
00093 j = rsGenQuery (rsComm, &genQueryInp, &genQueryOut);
00094
00095
00096
00097 if (j != CAT_NO_ROWS_FOUND) {
00098
00099 printGenQueryOut(stderr, NULL, NULL, genQueryOut);
00100
00101 dataName = getSqlResultByInx (genQueryOut, COL_DATA_NAME);
00102 dataOwner = getSqlResultByInx (genQueryOut, COL_D_OWNER_NAME);
00103
00104 ownerlist = strdup ((char*)ownerinp->inOutStruct);
00105
00106
00107 if (strlen(ownerlist)>0) {
00108 int ownercount=0;
00109
00110
00111 for (word=strtok(ownerlist, delims); word; word=strtok(NULL, delims)) {
00112
00113 char** tmp_list = 0;
00114 tmp_list = (char**) realloc (olist, sizeof (char*) * (ownercount));
00115 if( !tmp_list ) {
00116 rodsLog( LOG_ERROR, "msiVerifyOwner - realloc failure" );
00117 continue;
00118 } else {
00119 olist = tmp_list;
00120 }
00121 olist[ownercount] = strdup (word);
00122 ownercount++;
00123 }
00124
00125
00126 for (i=0; i<genQueryOut->rowCnt; i++) {
00127 int foundflag=0;
00128 for (j=0; j<ownercount; j++) {
00129 char* thisowner = strdup(&dataOwner->value[dataOwner->len*i]);
00130
00131
00132 if (!(strcmp(thisowner, olist[j]))) {
00133
00134 foundflag=1;
00135 break;
00136 }
00137 free( thisowner );
00138 }
00139
00140 if (!foundflag) {
00141 char tmpstr[80];
00142 sprintf (tmpstr, "File: %s with owner: %s does not match input list\n",
00143 &dataName->value[dataName->len *i], &dataOwner->value[dataOwner->len * i]);
00144 appendToByteBuf (stuff, tmpstr);
00145 }
00146 }
00147
00148 } else {
00149
00150 rodsLog (LOG_ERROR, "msiVerifyOwner: ownerlist is NULL");
00151
00152
00153
00154 char* firstowner = strdup(&dataOwner->value[0]);
00155
00156 int matchflag=1;
00157
00158 for (i=1; i<genQueryOut->rowCnt; i++) {
00159 char* thisowner = strdup( &dataOwner->value[dataOwner->len*i]);
00160 if (strcmp(firstowner, thisowner)) {
00161 appendToByteBuf (stuff, "Owner is not consistent across this collection");
00162 matchflag=0;
00163 break;
00164 }
00165 free( thisowner );
00166 }
00167
00168 if (matchflag)
00169 appendToByteBuf (stuff, "Owner is consistent across this collection.\n");
00170 else
00171 appendToByteBuf (stuff, "Owner is not consistent across this collection.\n");
00172
00173 free( firstowner );
00174
00175 }
00176
00177 free( olist );
00178 }
00179
00180 fillBufLenInMsParam (bufout, stuff->len, stuff);
00181 fillIntInMsParam (statout, rei->status);
00182 free( ownerlist );
00183 free( collname );
00184 return(rei->status);
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
00222
00223
00224
00225
00226
00227
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238
00239
00240
00241
00242
00243 int
00244 msiVerifyACL (msParam_t* collinp, msParam_t* userinp, msParam_t* authinp, msParam_t* notflaginp,
00245 msParam_t* bufout, msParam_t* statout, ruleExecInfo_t *rei)
00246 {
00247
00248 int i,j;
00249 int querytype=0;
00250 char tmpstr[MAX_NAME_LEN];
00251 genQueryInp_t gqin;
00252 genQueryOut_t* gqout = NULL;
00253 char* collname=NULL;
00254 char* collid=NULL;
00255 char* username=NULL;
00256 char* accessauth=NULL;
00257 char* notflag=NULL;
00258 rsComm_t *rsComm;
00259 bytesBuf_t* mybuf=NULL;
00260 sqlResult_t* collCollId;
00261 sqlResult_t* dataName;
00262 sqlResult_t* dataAccessName;
00263 sqlResult_t* dataAccessType;
00264 sqlResult_t* dataAccessDataId;
00265 sqlResult_t* dataAccessUserId;
00266
00267
00268 RE_TEST_MACRO (" Calling msiVerifyACL")
00269
00270
00271 if (rei == NULL || rei->rsComm == NULL) {
00272 rodsLog (LOG_ERROR, "msiVerifyACL: input rei or rsComm is NULL");
00273 return (SYS_INTERNAL_NULL_INPUT_ERR);
00274 }
00275 rsComm = rei->rsComm;
00276
00277
00278
00279
00280
00281
00282
00283
00284
00285
00286
00287
00288
00289
00290 collname = strdup ((char*)collinp->inOutStruct);
00291 if (collname == NULL) return (USER__NULL_INPUT_ERR);
00292
00293 username = strdup ((char*)userinp->inOutStruct);
00294 accessauth = strdup ((char*)authinp->inOutStruct);
00295 notflag = strdup ((char*)notflaginp->inOutStruct);
00296
00297 if ((username==NULL) && (accessauth==NULL)) {
00298 querytype=1;
00299 free( notflag );
00300 notflag=NULL;
00301 }
00302
00303 else if (((username==NULL) && (accessauth!=NULL)) || ((username!=NULL) && (accessauth==NULL))) {
00304 free( collname );
00305 free( username );
00306 free( accessauth );
00307 free( notflag );
00308 return (USER__NULL_INPUT_ERR);
00309 } else {
00310 if (atoi(notflag)==0)
00311 querytype=2;
00312 else
00313 querytype=3;
00314 }
00315
00316
00317
00318 gqout = (genQueryOut_t*) malloc (sizeof (genQueryOut_t));
00319 memset (gqout, 0, sizeof (genQueryOut_t));
00320 mybuf = (bytesBuf_t*) malloc(sizeof(bytesBuf_t));
00321 memset (mybuf, 0, sizeof (bytesBuf_t));
00322 gqin.maxRows = MAX_SQL_ROWS;
00323
00324
00325
00326
00327
00328 snprintf (tmpstr, MAX_NAME_LEN, " = '%s'", collname);
00329 addInxVal (&gqin.sqlCondInp, COL_COLL_NAME, tmpstr);
00330 addInxIval (&gqin.selectInp, COL_D_COLL_ID, 1);
00331
00332 j = rsGenQuery (rsComm, &gqin, &gqout);
00333
00334 if (j<0) {
00335 appendToByteBuf (mybuf, "Coll ID Not found\n");
00336 }
00337 else if (j != CAT_NO_ROWS_FOUND) {
00338
00339 printGenQueryOut(stderr, NULL, NULL, gqout);
00340
00341
00342 collCollId = getSqlResultByInx (gqout, COL_D_COLL_ID);
00343 collid = strdup (&collCollId->value[0]);
00344 sprintf (tmpstr, "Collection ID:%s\n", &collCollId->value[0]);
00345 appendToByteBuf (mybuf, tmpstr);
00346
00347 } else {
00348 appendToByteBuf (mybuf, "RAJA - what unknown error\n");
00349 free( collname );
00350 free( username );
00351 free( accessauth );
00352 return (1);
00353 }
00354
00355
00356 memset (&gqin, 0, sizeof (genQueryInp_t));
00357 gqin.maxRows = MAX_SQL_ROWS;
00358
00359 addInxIval (&gqin.selectInp, COL_DATA_NAME, 1);
00360 addInxIval (&gqin.selectInp, COL_DATA_ACCESS_NAME, 1);
00361 addInxIval (&gqin.selectInp, COL_DATA_ACCESS_TYPE, 1);
00362 addInxIval (&gqin.selectInp, COL_DATA_ACCESS_DATA_ID, 1);
00363 addInxIval (&gqin.selectInp, COL_DATA_ACCESS_USER_ID, 1);
00364
00365
00366
00367
00368
00369
00370 snprintf (tmpstr, MAX_NAME_LEN, " = '%s'", collid);
00371 addInxVal (&gqin.sqlCondInp, COL_D_COLL_ID, tmpstr);
00372
00373 j = rsGenQuery (rsComm, &gqin, &gqout);
00374
00375 if (j<0) {
00376 appendToByteBuf (mybuf, "Second gen query bad\n");
00377 } else if (j != CAT_NO_ROWS_FOUND) {
00378
00379 dataName = getSqlResultByInx (gqout, COL_DATA_NAME);
00380 dataAccessType = getSqlResultByInx (gqout, COL_DATA_ACCESS_TYPE);
00381 dataAccessName = getSqlResultByInx (gqout, COL_DATA_ACCESS_NAME);
00382 dataAccessDataId = getSqlResultByInx (gqout, COL_DATA_ACCESS_DATA_ID);
00383 dataAccessUserId = getSqlResultByInx (gqout, COL_DATA_ACCESS_USER_ID);
00384
00385
00386 for (i=0; i<gqout->rowCnt; i++) {
00387 sprintf (tmpstr, "Data name:%s\tData Access Type:%s\tData Access Name:%s\tData Access Data Id:%s\t Data Access User ID:%s\tNamespace:%s\n",
00388 &dataName->value[dataName->len *i],
00389 &dataAccessType->value[dataAccessType->len *i],
00390 &dataAccessName->value[dataAccessName->len *i],
00391 &dataAccessDataId->value[dataAccessDataId->len *i],
00392 &dataAccessUserId->value[dataAccessUserId->len *i],
00393
00394 "some namespace");
00395 appendToByteBuf (mybuf, tmpstr);
00396 }
00397
00398 printGenQueryOut(stderr, NULL, NULL, gqout);
00399 } else appendToByteBuf (mybuf, "something else gone bad RAJA");
00400
00401
00402 fillBufLenInMsParam (bufout, mybuf->len, mybuf);
00403 fillIntInMsParam (statout, rei->status);
00404
00405 free( collname );
00406 free( collid );
00407 return(rei->status);
00408
00409 return(0);
00410
00411 }
00412
00413
00414
00415
00416
00417
00418
00419
00420
00421
00422
00423
00424
00425
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 int
00453 msiVerifyExpiry (msParam_t* collinp, msParam_t* timeinp, msParam_t* typeinp, msParam_t* bufout, msParam_t* statout, ruleExecInfo_t* rei)
00454 {
00455
00456 rsComm_t *rsComm;
00457 genQueryInp_t gqin;
00458 genQueryOut_t *gqout = NULL;
00459 char condStr[MAX_NAME_LEN];
00460 char tmpstr[MAX_NAME_LEN];
00461 char* collname;
00462 sqlResult_t *dataName;
00463 sqlResult_t *dataExpiry;
00464 bytesBuf_t* mybuf=NULL;
00465 int i,j,status;
00466
00467 char* inputtime;
00468 char* querytype;
00469 int checkExpiredFlag=0;
00470 char inputtimestr[TIME_LEN];
00471
00472 RE_TEST_MACRO (" Calling msiVerifyExpiry")
00473
00474
00475 if (rei == NULL || rei->rsComm == NULL) {
00476 rodsLog (LOG_ERROR, "msiListFields: input rei or rsComm is NULL");
00477 return (SYS_INTERNAL_NULL_INPUT_ERR);
00478 }
00479
00480 rsComm = rei->rsComm;
00481
00482
00483 memset (&gqin, 0, sizeof(genQueryInp_t));
00484 gqin.maxRows = MAX_SQL_ROWS;
00485 mybuf = (bytesBuf_t *) malloc (sizeof (bytesBuf_t));
00486 memset (mybuf, 0, sizeof (bytesBuf_t));
00487 gqout = (genQueryOut_t*) malloc (sizeof (genQueryOut_t));
00488 memset (gqout, 0, sizeof (genQueryOut_t));
00489
00490
00491
00492 collname = strdup ((char*)collinp->inOutStruct);
00493 inputtime = strdup ((char*)timeinp->inOutStruct);
00494 querytype = strdup ((char*)typeinp->inOutStruct);
00495
00496
00497
00498
00499
00500
00501
00502
00503 if (collname==NULL) {
00504 free( gqout );
00505 free( mybuf );
00506 free( inputtime );
00507 free( querytype );
00508 return (USER_PARAM_TYPE_ERR);
00509 }
00510
00511
00512
00513 rstrcpy (inputtimestr, inputtime, TIME_LEN);
00514 status = checkDateFormat (inputtimestr);
00515 if (status < 0) {
00516 free( gqout );
00517 free( mybuf );
00518 free( inputtime );
00519 free( collname );
00520 free( querytype );
00521 return (DATE_FORMAT_ERR);
00522 }
00523
00524
00525 if (!strcmp(querytype, "EXPIRED")) {
00526 checkExpiredFlag = 1;
00527 } else if (!strcmp(querytype, "NOTEXPIRED")) {
00528 checkExpiredFlag = 0;
00529 } else {
00530 free( gqout );
00531 free( mybuf );
00532 free( inputtime );
00533 free( collname );
00534 free( querytype );
00535 return (USER_PARAM_TYPE_ERR);
00536 }
00537
00538
00539
00540 addInxIval (&gqin.selectInp, COL_DATA_NAME, 1);
00541 addInxIval (&gqin.selectInp, COL_D_EXPIRY , 1);
00542 snprintf (condStr, MAX_NAME_LEN, " = '%s'", collname);
00543 addInxVal (&gqin.sqlCondInp, COL_COLL_NAME, condStr);
00544
00545 j = rsGenQuery (rsComm, &gqin, &gqout);
00546
00547 if (j<0) {
00548
00549 appendToByteBuf (mybuf, "General Query was bad");
00550
00551 } else if (j != CAT_NO_ROWS_FOUND) {
00552
00553 int dataobjexpiry, inputtimeexpiry;
00554
00555 dataName = getSqlResultByInx (gqout, COL_DATA_NAME);
00556 dataExpiry = getSqlResultByInx (gqout, COL_D_EXPIRY);
00557 inputtimeexpiry = atoi (inputtimestr);
00558
00559 for (i=0; i<gqout->rowCnt; i++) {
00560 dataobjexpiry = atoi(&dataExpiry->value[dataExpiry->len*i]);
00561
00562
00563 if (checkExpiredFlag) {
00564 if (dataobjexpiry < inputtimeexpiry) {
00565 sprintf (tmpstr, "Data object:%s\twith Expiration date:%s has expired\n",
00566 &dataName->value[dataName->len *i], &dataExpiry->value[dataExpiry->len *i]);
00567 appendToByteBuf (mybuf, tmpstr);
00568 }
00569 } else {
00570 if (dataobjexpiry >= inputtimeexpiry) {
00571 sprintf (tmpstr, "Data object:%s\twith Expiration date:%s is expiring\n",
00572 &dataName->value[dataName->len *i], &dataExpiry->value[dataExpiry->len *i]);
00573 appendToByteBuf (mybuf, tmpstr);
00574 }
00575 }
00576
00577 }
00578 } else appendToByteBuf (mybuf, "No rows found\n");
00579
00580 fillBufLenInMsParam (bufout, mybuf->len, mybuf);
00581 fillIntInMsParam (statout, rei->status);
00582
00583 free( collname );
00584 free( querytime );
00585 free( querytype );
00586 return(rei->status);
00587
00588 }
00589
00590
00591
00592
00593
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
00630
00631
00632
00633
00634 int
00635 msiVerifyAVU (msParam_t* collinp, msParam_t* avunameinp, msParam_t* avuvalueinp, msParam_t* avuattrsinp,
00636 msParam_t* bufout, msParam_t* statout, ruleExecInfo_t* rei)
00637 {
00638
00639 genQueryInp_t gqin;
00640 genQueryOut_t *gqout1 = NULL;
00641 genQueryOut_t *gqout2 = NULL;
00642 char condStr[MAX_NAME_LEN];
00643 char tmpstr[MAX_NAME_LEN];
00644 rsComm_t *rsComm;
00645 int i,j;
00646 sqlResult_t *dataName;
00647 sqlResult_t *dataID1;
00648 sqlResult_t *dataID2;
00649 sqlResult_t *dataAttrName;
00650 sqlResult_t *dataAttrValue;
00651 sqlResult_t *dataAttrUnits;
00652 bytesBuf_t* mybuf=NULL;
00653 char* collname;
00654 char* inputattrname;
00655 char* inputattrvalue;
00656 char* inputattrunits;
00657
00658 RE_TEST_MACRO (" Calling msiVerifyAVU")
00659
00660
00661 if (rei == NULL || rei->rsComm == NULL) {
00662 rodsLog (LOG_ERROR, "msiVerifyAVU: input rei or rsComm is NULL");
00663 return (SYS_INTERNAL_NULL_INPUT_ERR);
00664 }
00665
00666
00667
00668
00669
00670
00671
00672
00673
00674
00675
00676
00677
00678
00679 rsComm = rei->rsComm;
00680
00681
00682 memset (&gqin, 0, sizeof (genQueryInp_t));
00683 gqin.maxRows = MAX_SQL_ROWS;
00684 mybuf = (bytesBuf_t*) malloc(sizeof(bytesBuf_t));
00685 memset (mybuf, 0, sizeof (bytesBuf_t));
00686 gqout1 = (genQueryOut_t*) malloc (sizeof (genQueryOut_t));
00687 memset (gqout1, 0, sizeof (genQueryOut_t));
00688 gqout2 = (genQueryOut_t*) malloc (sizeof (genQueryOut_t));
00689 memset (gqout2, 0, sizeof (genQueryOut_t));
00690
00691
00692
00693 collname = strdup ((char*)collinp->inOutStruct);
00694
00695
00696 addInxIval (&gqin.selectInp, COL_DATA_NAME, 1);
00697 addInxIval (&gqin.selectInp, COL_D_DATA_ID, 1);
00698 snprintf (condStr, MAX_NAME_LEN, " = '%s'", collname);
00699 addInxVal (&gqin.sqlCondInp, COL_COLL_NAME, condStr);
00700
00701 j = rsGenQuery (rsComm, &gqin, &gqout1);
00702
00703 if (j<0) {
00704 free( gqout2 );
00705 free( mybuf );
00706 free( collname );
00707 return (-1);
00708 }
00709 if (j != CAT_NO_ROWS_FOUND) {
00710
00711 printGenQueryOut(stderr, NULL, NULL, gqout1);
00712
00713
00714 memset (&gqin, 0, sizeof (genQueryInp_t));
00715 gqin.maxRows = MAX_SQL_ROWS;
00716
00717 addInxIval (&gqin.selectInp, COL_DATA_NAME, 1);
00718 addInxIval (&gqin.selectInp, COL_D_DATA_ID, 1);
00719 addInxIval (&gqin.selectInp, COL_META_DATA_ATTR_NAME, 1);
00720 addInxIval (&gqin.selectInp, COL_META_DATA_ATTR_VALUE, 1);
00721 addInxIval (&gqin.selectInp, COL_META_DATA_ATTR_UNITS, 1);
00722 snprintf (condStr, MAX_NAME_LEN, " = '%s'", collname);
00723 addInxVal (&gqin.sqlCondInp, COL_COLL_NAME, condStr);
00724
00725 j = rsGenQuery (rsComm, &gqin, &gqout2);
00726
00727 if (j != CAT_NO_ROWS_FOUND) {
00728
00729 int q1rows = gqout1->rowCnt;
00730 int q2rows = gqout2->rowCnt;
00731 int q1thisdataid, q2thisdataid;
00732 char* q1thisdataname = 0;
00733 char* thisdataattrname = 0;
00734 char* thisdataattrvalue = 0;
00735 char* thisdataattrunits = 0
00736
00737
00738
00739 dataName = getSqlResultByInx (gqout1, COL_DATA_NAME);
00740 dataID1 = getSqlResultByInx (gqout1, COL_D_DATA_ID);
00741 dataID2 = getSqlResultByInx (gqout2, COL_D_DATA_ID);
00742 dataAttrName = getSqlResultByInx (gqout2, COL_META_DATA_ATTR_NAME);
00743 dataAttrValue = getSqlResultByInx (gqout2, COL_META_DATA_ATTR_VALUE);
00744 dataAttrUnits = getSqlResultByInx (gqout2, COL_META_DATA_ATTR_UNITS);
00745
00746
00747 inputattrname = strdup ((char*)avunameinp->inOutStruct);
00748 inputattrvalue = strdup ((char*)avuvalueinp->inOutStruct);
00749 inputattrunits = strdup ((char*)avuattrsinp->inOutStruct);
00750
00751
00752 for (i=0; i<q1rows; i++) {
00753 int avufoundflag=0;
00754 if( q1thisdataname )
00755 free( q1thisdataname );
00756 q1thisdataname = strdup((&dataName->value[dataName->len*i]));
00757 q1thisdataid = atoi(&dataID1->value[dataID1->len*i]);
00758 for (j=0; j<q2rows; j++) {
00759 q2thisdataid = atoi(&dataID2->value[dataID2->len*j]);
00760 if (q1thisdataid == q2thisdataid) {
00761 avufoundflag=1;
00762
00763 thisdataattrname = strdup((&dataAttrName->value[dataAttrName->len*j]));
00764 thisdataattrvalue = strdup((&dataAttrValue->value[dataAttrValue->len*j]));
00765 thisdataattrunits = strdup((&dataAttrUnits->value[dataAttrUnits->len*j]));
00766 if (strcmp(thisdataattrname, inputattrname)) {
00767 sprintf (tmpstr, "Data object:%s with AVU:%s,%s,%s does not match input\n",
00768 q1thisdataname, thisdataattrname, thisdataattrvalue, thisdataattrunits);
00769 appendToByteBuf (mybuf, tmpstr);
00770 }
00771 if (strcmp(thisdataattrvalue, inputattrvalue)) {
00772 sprintf (tmpstr, "Data object:%s with AVU:%s,%s,%s does not match input\n",
00773 q1thisdataname, thisdataattrname, thisdataattrvalue, thisdataattrunits);
00774 appendToByteBuf (mybuf, tmpstr);
00775 }
00776 if (strcmp(thisdataattrunits, inputattrunits)) {
00777 sprintf (tmpstr, "Data object:%s with AVU:%s,%s,%s does not match input\n",
00778 q1thisdataname, thisdataattrname, thisdataattrvalue, thisdataattrunits);
00779 appendToByteBuf (mybuf, tmpstr);
00780 }
00781 break;
00782 }
00783
00784 }
00785 if (!avufoundflag) {
00786 sprintf (tmpstr, "Data object:%s has no AVU triplet set\n", q1thisdataname);
00787 appendToByteBuf (mybuf, tmpstr);
00788 }
00789
00790 }
00791
00792 free( q1thisdataname );
00793 free( thisdataattrname );
00794 free( thisdataattrvalue );
00795 free( thisdataattrunits );
00796
00797 } else {
00798
00799 }
00800 } else {
00801
00802 }
00803
00804 fillBufLenInMsParam (bufout, mybuf->len, mybuf);
00805 fillIntInMsParam (statout, rei->status);
00806
00807 free( collname );
00808 free( inputattrname );
00809 free( inputattrvalue );
00810 free( inputattrunits );
00811 return(rei->status);
00812
00813 }
00814
00815
00816
00817
00818
00819
00820
00821
00822
00823
00824
00825
00826
00827
00828
00829
00830
00831
00832
00833
00834
00835
00836
00837
00838
00839
00840
00841
00842
00843
00844
00845
00846
00847
00848
00849
00850
00851
00852
00853
00854
00855 int
00856 msiVerifyDataType (msParam_t* collinp, msParam_t* datatypeinp, msParam_t* bufout, msParam_t* statout, ruleExecInfo_t* rei)
00857 {
00858
00859 genQueryInp_t genQueryInp;
00860 genQueryOut_t *genQueryOut = NULL;
00861 char condStr[MAX_NAME_LEN];
00862 rsComm_t *rsComm;
00863 char collname[MAX_NAME_LEN];
00864 char datatypeparam[MAX_NAME_LEN];
00865 int i,j;
00866 sqlResult_t *dataName;
00867 sqlResult_t *dataType;
00868 char delims[]=",";
00869 char* word;
00870 keyValPair_t *results;
00871 char* key;
00872 char* value;
00873
00874 RE_TEST_MACRO (" Calling msiVerifyDataType")
00875
00876
00877 if (rei == NULL || rei->rsComm == NULL) {
00878 rodsLog (LOG_ERROR, "msiVerifyDataType: input rei or rsComm is NULL");
00879 return (SYS_INTERNAL_NULL_INPUT_ERR);
00880 }
00881
00882 rsComm = rei->rsComm;
00883
00884
00885 strcpy (collname, (char*) collinp->inOutStruct);
00886 strcpy (datatypeparam, (char*) datatypeinp->inOutStruct);
00887
00888 fprintf (stderr, "datatypeparam: %s\n", datatypeparam);
00889
00890
00891 results = (keyValPair_t*) malloc (sizeof(keyValPair_t));
00892 memset (results, 0, sizeof(keyValPair_t));
00893
00894
00895 for (word=strtok(datatypeparam, delims); word; word=strtok(NULL, delims)) {
00896
00897 fprintf (stderr, "word: %s\n", word);
00898
00899 memset (&genQueryInp, 0, sizeof(genQueryInp_t));
00900 genQueryInp.maxRows = MAX_SQL_ROWS;
00901
00902
00903 addInxIval (&genQueryInp.selectInp, COL_DATA_NAME, 1);
00904 addInxIval (&genQueryInp.selectInp, COL_DATA_TYPE_NAME, 1);
00905 snprintf (condStr, MAX_NAME_LEN, " = '%s'", word);
00906 addInxVal (&genQueryInp.sqlCondInp, COL_DATA_TYPE_NAME, condStr);
00907
00908
00909 j = rsGenQuery (rsComm, &genQueryInp, &genQueryOut);
00910
00911 if (j != CAT_NO_ROWS_FOUND) {
00912
00913 fprintf (stderr, "word: %s\trows:%d\n", word, genQueryOut->rowCnt);
00914
00915
00916 dataName = getSqlResultByInx (genQueryOut, COL_DATA_NAME);
00917 dataType = getSqlResultByInx (genQueryOut, COL_DATA_TYPE_NAME);
00918
00919 for (i=0; i<genQueryOut->rowCnt; i++) {
00920 key = strdup (&dataName->value[dataName->len *i]);
00921 value = strdup (&dataType->value[dataType->len * i]);
00922 addKeyVal (results, key, value);
00923 }
00924
00925 printGenQueryOut(stderr, NULL, NULL, genQueryOut);
00926
00927 } else continue;
00928
00929 }
00930
00931 fillMsParam (bufout, NULL, KeyValPair_MS_T, results, NULL);
00932 fillIntInMsParam (statout, rei->status);
00933
00934 return(rei->status);
00935
00936 }
00937
00938
00939
00940
00941
00942
00943
00944
00945
00946
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 int
00979 msiVerifyFileSizeRange (msParam_t* collinp, msParam_t* minsizeinp, msParam_t* maxsizeinp,
00980 msParam_t* bufout, msParam_t* statout, ruleExecInfo_t *rei)
00981 {
00982
00983 genQueryInp_t genQueryInp;
00984 genQueryOut_t *genQueryOut = NULL;
00985 char condStr[MAX_NAME_LEN];
00986 rsComm_t *rsComm;
00987 char collname[MAX_NAME_LEN];
00988 char maxfilesize[MAX_NAME_LEN];
00989 char minfilesize[MAX_NAME_LEN];
00990 int i,j;
00991 sqlResult_t *dataName;
00992 sqlResult_t *dataSize;
00993 keyValPair_t *results;
00994 char* key;
00995 char* value;
00996
00997 RE_TEST_MACRO (" Calling msiVerifyFileSizeRange")
00998
00999
01000 if (rei == NULL || rei->rsComm == NULL) {
01001 rodsLog (LOG_ERROR, "msiVerifyFileSizeRange: input rei or rsComm is NULL");
01002 return (SYS_INTERNAL_NULL_INPUT_ERR);
01003 }
01004
01005 rsComm = rei->rsComm;
01006
01007
01008 strcpy (collname, (char*) collinp->inOutStruct);
01009 strcpy (minfilesize, (char*) minsizeinp->inOutStruct);
01010 strcpy (maxfilesize, (char*) maxsizeinp->inOutStruct);
01011
01012
01013 if (atoi(minfilesize) >= atoi(maxfilesize)) {
01014 return (USER_PARAM_TYPE_ERR);
01015 }
01016
01017
01018 results = (keyValPair_t*) malloc (sizeof(keyValPair_t));
01019 memset (results, 0, sizeof(keyValPair_t));
01020
01021 memset (&genQueryInp, 0, sizeof(genQueryInp_t));
01022 genQueryInp.maxRows = MAX_SQL_ROWS;
01023
01024
01025 addInxIval (&genQueryInp.selectInp, COL_DATA_NAME, 1);
01026 addInxIval (&genQueryInp.selectInp, COL_DATA_SIZE, 1);
01027 addInxIval (&genQueryInp.selectInp, COL_COLL_NAME, 1);
01028
01029
01030
01031
01032 snprintf (condStr, MAX_NAME_LEN, " < '%s' || > '%s'", minfilesize, maxfilesize);
01033 addInxVal (&genQueryInp.sqlCondInp, COL_DATA_SIZE, condStr);
01034 snprintf (condStr, MAX_NAME_LEN, " = '%s'", collname);
01035 addInxVal (&genQueryInp.sqlCondInp, COL_COLL_NAME, condStr);
01036
01037 j = rsGenQuery (rsComm, &genQueryInp, &genQueryOut);
01038
01039 if (j != CAT_NO_ROWS_FOUND) {
01040
01041
01042 dataName = getSqlResultByInx (genQueryOut, COL_DATA_NAME);
01043 dataSize = getSqlResultByInx (genQueryOut, COL_DATA_SIZE);
01044 for (i=0; i<genQueryOut->rowCnt; i++) {
01045
01046 key = strdup (&dataName->value[dataName->len *i]);
01047
01048 value = strdup (&dataSize->value[dataSize->len * i]);
01049 addKeyVal (results, key, value);
01050 }
01051
01052 } else {
01053 fillIntInMsParam (statout, rei->status);
01054 return (rei->status);
01055 }
01056
01057
01058
01059 fillMsParam (bufout, NULL, KeyValPair_MS_T, results, NULL);
01060 fillIntInMsParam (statout, rei->status);
01061
01062 return(rei->status);
01063
01064 }
01065