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 return (USER__NULL_INPUT_ERR);
00306 } else {
00307 if (atoi(notflag)==0)
00308 querytype=2;
00309 else
00310 querytype=3;
00311 }
00312
00313
00314
00315 gqout = (genQueryOut_t*) malloc (sizeof (genQueryOut_t));
00316 memset (gqout, 0, sizeof (genQueryOut_t));
00317 mybuf = (bytesBuf_t*) malloc(sizeof(bytesBuf_t));
00318 memset (mybuf, 0, sizeof (bytesBuf_t));
00319 gqin.maxRows = MAX_SQL_ROWS;
00320
00321
00322
00323
00324
00325 snprintf (tmpstr, MAX_NAME_LEN, " = '%s'", collname);
00326 addInxVal (&gqin.sqlCondInp, COL_COLL_NAME, tmpstr);
00327 addInxIval (&gqin.selectInp, COL_D_COLL_ID, 1);
00328
00329 j = rsGenQuery (rsComm, &gqin, &gqout);
00330
00331 if (j<0) {
00332 appendToByteBuf (mybuf, "Coll ID Not found\n");
00333 }
00334 else if (j != CAT_NO_ROWS_FOUND) {
00335
00336 printGenQueryOut(stderr, NULL, NULL, gqout);
00337
00338
00339 collCollId = getSqlResultByInx (gqout, COL_D_COLL_ID);
00340 collid = strdup (&collCollId->value[0]);
00341 sprintf (tmpstr, "Collection ID:%s\n", &collCollId->value[0]);
00342 appendToByteBuf (mybuf, tmpstr);
00343
00344 } else {
00345 appendToByteBuf (mybuf, "RAJA - what unknown error\n");
00346 free( collname );
00347 return (1);
00348 }
00349
00350
00351 memset (&gqin, 0, sizeof (genQueryInp_t));
00352 gqin.maxRows = MAX_SQL_ROWS;
00353
00354 addInxIval (&gqin.selectInp, COL_DATA_NAME, 1);
00355 addInxIval (&gqin.selectInp, COL_DATA_ACCESS_NAME, 1);
00356 addInxIval (&gqin.selectInp, COL_DATA_ACCESS_TYPE, 1);
00357 addInxIval (&gqin.selectInp, COL_DATA_ACCESS_DATA_ID, 1);
00358 addInxIval (&gqin.selectInp, COL_DATA_ACCESS_USER_ID, 1);
00359
00360
00361
00362
00363
00364
00365 snprintf (tmpstr, MAX_NAME_LEN, " = '%s'", collid);
00366 addInxVal (&gqin.sqlCondInp, COL_D_COLL_ID, tmpstr);
00367
00368 j = rsGenQuery (rsComm, &gqin, &gqout);
00369
00370 if (j<0) {
00371 appendToByteBuf (mybuf, "Second gen query bad\n");
00372 } else if (j != CAT_NO_ROWS_FOUND) {
00373
00374 dataName = getSqlResultByInx (gqout, COL_DATA_NAME);
00375 dataAccessType = getSqlResultByInx (gqout, COL_DATA_ACCESS_TYPE);
00376 dataAccessName = getSqlResultByInx (gqout, COL_DATA_ACCESS_NAME);
00377 dataAccessDataId = getSqlResultByInx (gqout, COL_DATA_ACCESS_DATA_ID);
00378 dataAccessUserId = getSqlResultByInx (gqout, COL_DATA_ACCESS_USER_ID);
00379
00380
00381 for (i=0; i<gqout->rowCnt; i++) {
00382 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",
00383 &dataName->value[dataName->len *i],
00384 &dataAccessType->value[dataAccessType->len *i],
00385 &dataAccessName->value[dataAccessName->len *i],
00386 &dataAccessDataId->value[dataAccessDataId->len *i],
00387 &dataAccessUserId->value[dataAccessUserId->len *i],
00388
00389 "some namespace");
00390 appendToByteBuf (mybuf, tmpstr);
00391 }
00392
00393 printGenQueryOut(stderr, NULL, NULL, gqout);
00394 } else appendToByteBuf (mybuf, "something else gone bad RAJA");
00395
00396
00397 fillBufLenInMsParam (bufout, mybuf->len, mybuf);
00398 fillIntInMsParam (statout, rei->status);
00399
00400 free( collname );
00401 free( collid );
00402 return(rei->status);
00403
00404 return(0);
00405
00406 }
00407
00408
00409
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 int
00448 msiVerifyExpiry (msParam_t* collinp, msParam_t* timeinp, msParam_t* typeinp, msParam_t* bufout, msParam_t* statout, ruleExecInfo_t* rei)
00449 {
00450
00451 rsComm_t *rsComm;
00452 genQueryInp_t gqin;
00453 genQueryOut_t *gqout = NULL;
00454 char condStr[MAX_NAME_LEN];
00455 char tmpstr[MAX_NAME_LEN];
00456 char* collname;
00457 sqlResult_t *dataName;
00458 sqlResult_t *dataExpiry;
00459 bytesBuf_t* mybuf=NULL;
00460 int i,j,status;
00461
00462 char* inputtime;
00463 char* querytype;
00464 int checkExpiredFlag=0;
00465 char inputtimestr[TIME_LEN];
00466
00467 RE_TEST_MACRO (" Calling msiVerifyExpiry")
00468
00469
00470 if (rei == NULL || rei->rsComm == NULL) {
00471 rodsLog (LOG_ERROR, "msiListFields: input rei or rsComm is NULL");
00472 return (SYS_INTERNAL_NULL_INPUT_ERR);
00473 }
00474
00475 rsComm = rei->rsComm;
00476
00477
00478 memset (&gqin, 0, sizeof(genQueryInp_t));
00479 gqin.maxRows = MAX_SQL_ROWS;
00480 mybuf = (bytesBuf_t *) malloc (sizeof (bytesBuf_t));
00481 memset (mybuf, 0, sizeof (bytesBuf_t));
00482 gqout = (genQueryOut_t*) malloc (sizeof (genQueryOut_t));
00483 memset (gqout, 0, sizeof (genQueryOut_t));
00484
00485
00486
00487 collname = strdup ((char*)collinp->inOutStruct);
00488 inputtime = strdup ((char*)timeinp->inOutStruct);
00489 querytype = strdup ((char*)typeinp->inOutStruct);
00490
00491
00492
00493
00494
00495
00496
00497
00498 if (collname==NULL) {
00499 free( gqout );
00500 free( mybuf );
00501 free( inputtime );
00502 free( querytype );
00503 return (USER_PARAM_TYPE_ERR);
00504 }
00505
00506
00507
00508 rstrcpy (inputtimestr, inputtime, TIME_LEN);
00509 status = checkDateFormat (inputtimestr);
00510 if (status < 0) {
00511 free( gqout );
00512 free( mybuf );
00513 free( inputtime );
00514 free( collname );
00515 free( querytype );
00516 return (DATE_FORMAT_ERR);
00517 }
00518
00519
00520 if (!strcmp(querytype, "EXPIRED")) {
00521 checkExpiredFlag = 1;
00522 } else if (!strcmp(querytype, "NOTEXPIRED")) {
00523 checkExpiredFlag = 0;
00524 } else {
00525 free( gqout );
00526 free( mybuf );
00527 free( inputtime );
00528 free( collname );
00529 free( querytype );
00530 return (USER_PARAM_TYPE_ERR);
00531 }
00532
00533
00534
00535 addInxIval (&gqin.selectInp, COL_DATA_NAME, 1);
00536 addInxIval (&gqin.selectInp, COL_D_EXPIRY , 1);
00537 snprintf (condStr, MAX_NAME_LEN, " = '%s'", collname);
00538 addInxVal (&gqin.sqlCondInp, COL_COLL_NAME, condStr);
00539
00540 j = rsGenQuery (rsComm, &gqin, &gqout);
00541
00542 if (j<0) {
00543
00544 appendToByteBuf (mybuf, "General Query was bad");
00545
00546 } else if (j != CAT_NO_ROWS_FOUND) {
00547
00548 int dataobjexpiry, inputtimeexpiry;
00549
00550 dataName = getSqlResultByInx (gqout, COL_DATA_NAME);
00551 dataExpiry = getSqlResultByInx (gqout, COL_D_EXPIRY);
00552 inputtimeexpiry = atoi (inputtimestr);
00553
00554 for (i=0; i<gqout->rowCnt; i++) {
00555 dataobjexpiry = atoi(&dataExpiry->value[dataExpiry->len*i]);
00556
00557
00558 if (checkExpiredFlag) {
00559 if (dataobjexpiry < inputtimeexpiry) {
00560 sprintf (tmpstr, "Data object:%s\twith Expiration date:%s has expired\n",
00561 &dataName->value[dataName->len *i], &dataExpiry->value[dataExpiry->len *i]);
00562 appendToByteBuf (mybuf, tmpstr);
00563 }
00564 } else {
00565 if (dataobjexpiry >= inputtimeexpiry) {
00566 sprintf (tmpstr, "Data object:%s\twith Expiration date:%s is expiring\n",
00567 &dataName->value[dataName->len *i], &dataExpiry->value[dataExpiry->len *i]);
00568 appendToByteBuf (mybuf, tmpstr);
00569 }
00570 }
00571
00572 }
00573 } else appendToByteBuf (mybuf, "No rows found\n");
00574
00575 fillBufLenInMsParam (bufout, mybuf->len, mybuf);
00576 fillIntInMsParam (statout, rei->status);
00577
00578 free( collname );
00579 free( querytime );
00580 free( querytype );
00581 return(rei->status);
00582
00583 }
00584
00585
00586
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 int
00630 msiVerifyAVU (msParam_t* collinp, msParam_t* avunameinp, msParam_t* avuvalueinp, msParam_t* avuattrsinp,
00631 msParam_t* bufout, msParam_t* statout, ruleExecInfo_t* rei)
00632 {
00633
00634 genQueryInp_t gqin;
00635 genQueryOut_t *gqout1 = NULL;
00636 genQueryOut_t *gqout2 = NULL;
00637 char condStr[MAX_NAME_LEN];
00638 char tmpstr[MAX_NAME_LEN];
00639 rsComm_t *rsComm;
00640 int i,j;
00641 sqlResult_t *dataName;
00642 sqlResult_t *dataID1;
00643 sqlResult_t *dataID2;
00644 sqlResult_t *dataAttrName;
00645 sqlResult_t *dataAttrValue;
00646 sqlResult_t *dataAttrUnits;
00647 bytesBuf_t* mybuf=NULL;
00648 char* collname;
00649 char* inputattrname;
00650 char* inputattrvalue;
00651 char* inputattrunits;
00652
00653 RE_TEST_MACRO (" Calling msiVerifyAVU")
00654
00655
00656 if (rei == NULL || rei->rsComm == NULL) {
00657 rodsLog (LOG_ERROR, "msiVerifyAVU: input rei or rsComm is NULL");
00658 return (SYS_INTERNAL_NULL_INPUT_ERR);
00659 }
00660
00661
00662
00663
00664
00665
00666
00667
00668
00669
00670
00671
00672
00673
00674 rsComm = rei->rsComm;
00675
00676
00677 memset (&gqin, 0, sizeof (genQueryInp_t));
00678 gqin.maxRows = MAX_SQL_ROWS;
00679 mybuf = (bytesBuf_t*) malloc(sizeof(bytesBuf_t));
00680 memset (mybuf, 0, sizeof (bytesBuf_t));
00681 gqout1 = (genQueryOut_t*) malloc (sizeof (genQueryOut_t));
00682 memset (gqout1, 0, sizeof (genQueryOut_t));
00683 gqout2 = (genQueryOut_t*) malloc (sizeof (genQueryOut_t));
00684 memset (gqout2, 0, sizeof (genQueryOut_t));
00685
00686
00687
00688 collname = strdup ((char*)collinp->inOutStruct);
00689
00690
00691 addInxIval (&gqin.selectInp, COL_DATA_NAME, 1);
00692 addInxIval (&gqin.selectInp, COL_D_DATA_ID, 1);
00693 snprintf (condStr, MAX_NAME_LEN, " = '%s'", collname);
00694 addInxVal (&gqin.sqlCondInp, COL_COLL_NAME, condStr);
00695
00696 j = rsGenQuery (rsComm, &gqin, &gqout1);
00697
00698 if (j<0) {
00699 free( gqout2 );
00700 free( mybuf );
00701 free( collname );
00702 return (-1);
00703 }
00704 if (j != CAT_NO_ROWS_FOUND) {
00705
00706 printGenQueryOut(stderr, NULL, NULL, gqout1);
00707
00708
00709 memset (&gqin, 0, sizeof (genQueryInp_t));
00710 gqin.maxRows = MAX_SQL_ROWS;
00711
00712 addInxIval (&gqin.selectInp, COL_DATA_NAME, 1);
00713 addInxIval (&gqin.selectInp, COL_D_DATA_ID, 1);
00714 addInxIval (&gqin.selectInp, COL_META_DATA_ATTR_NAME, 1);
00715 addInxIval (&gqin.selectInp, COL_META_DATA_ATTR_VALUE, 1);
00716 addInxIval (&gqin.selectInp, COL_META_DATA_ATTR_UNITS, 1);
00717 snprintf (condStr, MAX_NAME_LEN, " = '%s'", collname);
00718 addInxVal (&gqin.sqlCondInp, COL_COLL_NAME, condStr);
00719
00720 j = rsGenQuery (rsComm, &gqin, &gqout2);
00721
00722 if (j != CAT_NO_ROWS_FOUND) {
00723
00724 int q1rows = gqout1->rowCnt;
00725 int q2rows = gqout2->rowCnt;
00726 int q1thisdataid, q2thisdataid;
00727 char* q1thisdataname = 0;
00728 char* thisdataattrname = 0;
00729 char* thisdataattrvalue = 0;
00730 char* thisdataattrunits = 0
00731
00732
00733
00734 dataName = getSqlResultByInx (gqout1, COL_DATA_NAME);
00735 dataID1 = getSqlResultByInx (gqout1, COL_D_DATA_ID);
00736 dataID2 = getSqlResultByInx (gqout2, COL_D_DATA_ID);
00737 dataAttrName = getSqlResultByInx (gqout2, COL_META_DATA_ATTR_NAME);
00738 dataAttrValue = getSqlResultByInx (gqout2, COL_META_DATA_ATTR_VALUE);
00739 dataAttrUnits = getSqlResultByInx (gqout2, COL_META_DATA_ATTR_UNITS);
00740
00741
00742 inputattrname = strdup ((char*)avunameinp->inOutStruct);
00743 inputattrvalue = strdup ((char*)avuvalueinp->inOutStruct);
00744 inputattrunits = strdup ((char*)avuattrsinp->inOutStruct);
00745
00746
00747 for (i=0; i<q1rows; i++) {
00748 int avufoundflag=0;
00749 if( q1thisdataname )
00750 free( q1thisdataname );
00751 q1thisdataname = strdup((&dataName->value[dataName->len*i]));
00752 q1thisdataid = atoi(&dataID1->value[dataID1->len*i]);
00753 for (j=0; j<q2rows; j++) {
00754 q2thisdataid = atoi(&dataID2->value[dataID2->len*j]);
00755 if (q1thisdataid == q2thisdataid) {
00756 avufoundflag=1;
00757
00758 thisdataattrname = strdup((&dataAttrName->value[dataAttrName->len*j]));
00759 thisdataattrvalue = strdup((&dataAttrValue->value[dataAttrValue->len*j]));
00760 thisdataattrunits = strdup((&dataAttrUnits->value[dataAttrUnits->len*j]));
00761 if (strcmp(thisdataattrname, inputattrname)) {
00762 sprintf (tmpstr, "Data object:%s with AVU:%s,%s,%s does not match input\n",
00763 q1thisdataname, thisdataattrname, thisdataattrvalue, thisdataattrunits);
00764 appendToByteBuf (mybuf, tmpstr);
00765 }
00766 if (strcmp(thisdataattrvalue, inputattrvalue)) {
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(thisdataattrunits, inputattrunits)) {
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 break;
00777 }
00778
00779 }
00780 if (!avufoundflag) {
00781 sprintf (tmpstr, "Data object:%s has no AVU triplet set\n", q1thisdataname);
00782 appendToByteBuf (mybuf, tmpstr);
00783 }
00784
00785 }
00786
00787 free( q1thisdataname );
00788 free( thisdataattrname );
00789 free( thisdataattrvalue );
00790 free( thisdataattrunits );
00791
00792 } else {
00793
00794 }
00795 } else {
00796
00797 }
00798
00799 fillBufLenInMsParam (bufout, mybuf->len, mybuf);
00800 fillIntInMsParam (statout, rei->status);
00801
00802 free( collname );
00803 free( inputattrname );
00804 free( inputattrvalue );
00805 free( inputattrunits );
00806 return(rei->status);
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
00835
00836
00837
00838
00839
00840
00841
00842
00843
00844
00845
00846
00847
00848
00849
00850 int
00851 msiVerifyDataType (msParam_t* collinp, msParam_t* datatypeinp, msParam_t* bufout, msParam_t* statout, ruleExecInfo_t* rei)
00852 {
00853
00854 genQueryInp_t genQueryInp;
00855 genQueryOut_t *genQueryOut = NULL;
00856 char condStr[MAX_NAME_LEN];
00857 rsComm_t *rsComm;
00858 char collname[MAX_NAME_LEN];
00859 char datatypeparam[MAX_NAME_LEN];
00860 int i,j;
00861 sqlResult_t *dataName;
00862 sqlResult_t *dataType;
00863 char delims[]=",";
00864 char* word;
00865 keyValPair_t *results;
00866 char* key;
00867 char* value;
00868
00869 RE_TEST_MACRO (" Calling msiVerifyDataType")
00870
00871
00872 if (rei == NULL || rei->rsComm == NULL) {
00873 rodsLog (LOG_ERROR, "msiVerifyDataType: input rei or rsComm is NULL");
00874 return (SYS_INTERNAL_NULL_INPUT_ERR);
00875 }
00876
00877 rsComm = rei->rsComm;
00878
00879
00880 strcpy (collname, (char*) collinp->inOutStruct);
00881 strcpy (datatypeparam, (char*) datatypeinp->inOutStruct);
00882
00883 fprintf (stderr, "datatypeparam: %s\n", datatypeparam);
00884
00885
00886 results = (keyValPair_t*) malloc (sizeof(keyValPair_t));
00887 memset (results, 0, sizeof(keyValPair_t));
00888
00889
00890 for (word=strtok(datatypeparam, delims); word; word=strtok(NULL, delims)) {
00891
00892 fprintf (stderr, "word: %s\n", word);
00893
00894 memset (&genQueryInp, 0, sizeof(genQueryInp_t));
00895 genQueryInp.maxRows = MAX_SQL_ROWS;
00896
00897
00898 addInxIval (&genQueryInp.selectInp, COL_DATA_NAME, 1);
00899 addInxIval (&genQueryInp.selectInp, COL_DATA_TYPE_NAME, 1);
00900 snprintf (condStr, MAX_NAME_LEN, " = '%s'", word);
00901 addInxVal (&genQueryInp.sqlCondInp, COL_DATA_TYPE_NAME, condStr);
00902
00903
00904 j = rsGenQuery (rsComm, &genQueryInp, &genQueryOut);
00905
00906 if (j != CAT_NO_ROWS_FOUND) {
00907
00908 fprintf (stderr, "word: %s\trows:%d\n", word, genQueryOut->rowCnt);
00909
00910
00911 dataName = getSqlResultByInx (genQueryOut, COL_DATA_NAME);
00912 dataType = getSqlResultByInx (genQueryOut, COL_DATA_TYPE_NAME);
00913
00914 for (i=0; i<genQueryOut->rowCnt; i++) {
00915 key = strdup (&dataName->value[dataName->len *i]);
00916 value = strdup (&dataType->value[dataType->len * i]);
00917 addKeyVal (results, key, value);
00918 }
00919
00920 printGenQueryOut(stderr, NULL, NULL, genQueryOut);
00921
00922 } else continue;
00923
00924 }
00925
00926 fillMsParam (bufout, NULL, KeyValPair_MS_T, results, NULL);
00927 fillIntInMsParam (statout, rei->status);
00928
00929 return(rei->status);
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
00955
00956
00957
00958
00959
00960
00961
00962
00963
00964
00965
00966
00967
00968
00969
00970
00971
00972
00973 int
00974 msiVerifyFileSizeRange (msParam_t* collinp, msParam_t* minsizeinp, msParam_t* maxsizeinp,
00975 msParam_t* bufout, msParam_t* statout, ruleExecInfo_t *rei)
00976 {
00977
00978 genQueryInp_t genQueryInp;
00979 genQueryOut_t *genQueryOut = NULL;
00980 char condStr[MAX_NAME_LEN];
00981 rsComm_t *rsComm;
00982 char collname[MAX_NAME_LEN];
00983 char maxfilesize[MAX_NAME_LEN];
00984 char minfilesize[MAX_NAME_LEN];
00985 int i,j;
00986 sqlResult_t *dataName;
00987 sqlResult_t *dataSize;
00988 keyValPair_t *results;
00989 char* key;
00990 char* value;
00991
00992 RE_TEST_MACRO (" Calling msiVerifyFileSizeRange")
00993
00994
00995 if (rei == NULL || rei->rsComm == NULL) {
00996 rodsLog (LOG_ERROR, "msiVerifyFileSizeRange: input rei or rsComm is NULL");
00997 return (SYS_INTERNAL_NULL_INPUT_ERR);
00998 }
00999
01000 rsComm = rei->rsComm;
01001
01002
01003 strcpy (collname, (char*) collinp->inOutStruct);
01004 strcpy (minfilesize, (char*) minsizeinp->inOutStruct);
01005 strcpy (maxfilesize, (char*) maxsizeinp->inOutStruct);
01006
01007
01008 if (atoi(minfilesize) >= atoi(maxfilesize)) {
01009 return (USER_PARAM_TYPE_ERR);
01010 }
01011
01012
01013 results = (keyValPair_t*) malloc (sizeof(keyValPair_t));
01014 memset (results, 0, sizeof(keyValPair_t));
01015
01016 memset (&genQueryInp, 0, sizeof(genQueryInp_t));
01017 genQueryInp.maxRows = MAX_SQL_ROWS;
01018
01019
01020 addInxIval (&genQueryInp.selectInp, COL_DATA_NAME, 1);
01021 addInxIval (&genQueryInp.selectInp, COL_DATA_SIZE, 1);
01022 addInxIval (&genQueryInp.selectInp, COL_COLL_NAME, 1);
01023
01024
01025
01026
01027 snprintf (condStr, MAX_NAME_LEN, " < '%s' || > '%s'", minfilesize, maxfilesize);
01028 addInxVal (&genQueryInp.sqlCondInp, COL_DATA_SIZE, condStr);
01029 snprintf (condStr, MAX_NAME_LEN, " = '%s'", collname);
01030 addInxVal (&genQueryInp.sqlCondInp, COL_COLL_NAME, condStr);
01031
01032 j = rsGenQuery (rsComm, &genQueryInp, &genQueryOut);
01033
01034 if (j != CAT_NO_ROWS_FOUND) {
01035
01036
01037 dataName = getSqlResultByInx (genQueryOut, COL_DATA_NAME);
01038 dataSize = getSqlResultByInx (genQueryOut, COL_DATA_SIZE);
01039 for (i=0; i<genQueryOut->rowCnt; i++) {
01040
01041 key = strdup (&dataName->value[dataName->len *i]);
01042
01043 value = strdup (&dataSize->value[dataSize->len * i]);
01044 addKeyVal (results, key, value);
01045 }
01046
01047 } else {
01048 fillIntInMsParam (statout, rei->status);
01049 return (rei->status);
01050 }
01051
01052
01053
01054 fillMsParam (bufout, NULL, KeyValPair_MS_T, results, NULL);
01055 fillIntInMsParam (statout, rei->status);
01056
01057 return(rei->status);
01058
01059 }
01060