00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 #include "rods.h"
00022 #include "rcMisc.h"
00023
00024 #include "dboHighLevelRoutines.h"
00025 #include "icatLowLevel.h"
00026
00027 #include "dataObjOpen.h"
00028 #include "dataObjRead.h"
00029 #include "dataObjClose.h"
00030 #include "dataObjCreate.h"
00031 #include "dataObjWrite.h"
00032
00033 #define DBR_CONFIG_FILE "dbr.config"
00034 #define DBR_ODBC_ENTRY_PREFIX "IRODS_DBR_"
00035 #define MAX_ODBC_ENTRY_NAME 100
00036
00037 #define DBR_ACCESS_READ 1
00038 #define DBR_ACCESS_WRITE 2
00039 #define DBR_ACCESS_OWN 3
00040
00041 #define BUF_LEN 500
00042 #define MAX_SQL 4000
00043
00044 #define MAX_DBR_NAME_LEN 200
00045 #define BIG_STR 200
00046
00047 #define LOCAL_BUFFER_SIZE 1000000
00048 #define MAX_SESSIONS 10
00049 static char openDbrName[MAX_SESSIONS][MAX_DBR_NAME_LEN+2]={"","","","","","","","","",""};
00050
00051 int dboLogSQL=0;
00052
00053 int readDbrConfig(char *dbrname, char *DBUser, char *DBPasswd,char *DBType);
00054
00055 icatSessionStruct dbr_icss[MAX_SESSIONS]={{0},{0},{0},{0},{0},{0},{0},{0},{0},{0}};
00056
00057 int dboDebug(char *debugMode) {
00058 if (strstr(debugMode, "SQL")) {
00059 dboLogSQL=1;
00060 }
00061 else {
00062 dboLogSQL=0;
00063 }
00064 return(0);
00065 }
00066
00067 int
00068 getOpenDbrIndex(char *dbrName) {
00069 int ix, i;
00070 ix=-1;
00071 for (i=0;i<MAX_SESSIONS;i++) {
00072 if (strcmp(openDbrName[i], dbrName)==0) {
00073 ix = i;
00074 break;
00075 }
00076 }
00077 return(ix);
00078 }
00079
00080
00081 int dbrOpen(char *dbrName) {
00082 #if defined(DBR)
00083 int i;
00084 int status;
00085 char DBType[DB_TYPENAME_LEN];
00086 int icss_index;
00087 char odbcEntryName[MAX_ODBC_ENTRY_NAME+10];
00088
00089 i = getOpenDbrIndex(dbrName);
00090 if (i>=0) return(DBR_ALREADY_OPEN);
00091
00092 icss_index = -1;
00093 for (i=0;i<MAX_SESSIONS;i++) {
00094 if (dbr_icss[i].status==0) {
00095 icss_index=i;
00096 break;
00097 }
00098 }
00099 if (icss_index==-1) return (DBR_MAX_SESSIONS_REACHED);
00100
00101 status = readDbrConfig(dbrName,
00102 dbr_icss[icss_index].databaseUsername,
00103 dbr_icss[icss_index].databasePassword,
00104 DBType);
00105 if (status) return(status);
00106
00107 dbr_icss[icss_index].databaseType = DB_TYPE_POSTGRES;
00108 if (strcmp(DBType, "oracle")==0) {
00109 dbr_icss[icss_index].databaseType = DB_TYPE_ORACLE;
00110 }
00111 if (strcmp(DBType, "mysql")==0) {
00112 dbr_icss[icss_index].databaseType = DB_TYPE_MYSQL;
00113 }
00114
00115
00116 for (i=0; i<MAX_NUM_OF_CONCURRENT_STMTS; i++) {
00117 dbr_icss[icss_index].stmtPtr[i]=0;
00118 }
00119
00120
00121 i = cllOpenEnv(&dbr_icss[icss_index]);
00122 if (i != 0) {
00123 rodsLog(LOG_NOTICE, "dbrOpen cllOpen failure %d",i);
00124 return(DBR_ENV_ERR);
00125 }
00126
00127
00128 rstrcpy((char *)&odbcEntryName, DBR_ODBC_ENTRY_PREFIX,
00129 MAX_ODBC_ENTRY_NAME);
00130 rstrcat((char *)&odbcEntryName, dbrName,
00131 MAX_ODBC_ENTRY_NAME);
00132 i = cllConnectDbr(&dbr_icss[icss_index], odbcEntryName);
00133 if (i != 0) {
00134 rodsLog(LOG_NOTICE, "dbrOpen cllConnectDbr failure %d",i);
00135 return(DBR_CONNECT_ERR);
00136 }
00137
00138 dbr_icss[icss_index].status=1;
00139 rstrcpy(openDbrName[icss_index], dbrName, MAX_DBR_NAME_LEN);
00140
00141 return(icss_index);
00142 #else
00143 openDbrName[0][0]='\0';
00144 return(DBR_NOT_COMPILED_IN);
00145 #endif
00146 }
00147
00148
00149 int _dbrClose(int icss_index) {
00150 #if defined(DBR)
00151 int status, stat2;
00152
00153 status = cllDisconnect(&dbr_icss[icss_index]);
00154
00155 stat2 = cllCloseEnv(&dbr_icss[icss_index]);
00156
00157 openDbrName[icss_index][0]='\0';
00158
00159 if (status) {
00160 return(DBR_DISCONNECT_ERR);
00161 }
00162 if (stat2) {
00163 return(DBR_CLOSE_ENV_ERR);
00164 }
00165 dbr_icss[icss_index].status=0;
00166 openDbrName[icss_index][0] = '\0';
00167 return(0);
00168 #else
00169 return(DBR_NOT_COMPILED_IN);
00170 #endif
00171 }
00172
00173 int dbrClose(char *dbrName) {
00174 #if defined(DBR)
00175 int i;
00176 for (i=0;i<MAX_SESSIONS;i++) {
00177 if (strcmp(openDbrName[i], dbrName)==0) {
00178 return(_dbrClose(i));
00179 }
00180 }
00181 return(DBR_NOT_OPEN);
00182 #else
00183 return(DBR_NOT_COMPILED_IN);
00184 #endif
00185 }
00186
00187 int dbrCommit(rsComm_t *rsComm, char *dbrName) {
00188 #if defined(DBR)
00189 int status, ix;
00190
00191 if (rsComm->clientUser.authInfo.authFlag < LOCAL_PRIV_USER_AUTH) {
00192 return(CAT_INSUFFICIENT_PRIVILEGE_LEVEL);
00193 }
00194
00195 ix = getOpenDbrIndex(dbrName);
00196
00197 if (ix<0) return(DBR_NOT_OPEN);
00198
00199 status = cllExecSqlNoResult(&dbr_icss[ix], "commit");
00200 return(status);
00201 #else
00202 return(DBR_NOT_COMPILED_IN);
00203 #endif
00204 }
00205
00206 int dbrRollback(rsComm_t *rsComm, char *dbrName) {
00207 #if defined(DBR)
00208 int status, ix;
00209
00210 if (rsComm->clientUser.authInfo.authFlag < LOCAL_PRIV_USER_AUTH) {
00211 return(CAT_INSUFFICIENT_PRIVILEGE_LEVEL);
00212 }
00213
00214 ix = getOpenDbrIndex(dbrName);
00215
00216 if (ix<0) return(DBR_NOT_OPEN);
00217
00218 status = cllExecSqlNoResult(&dbr_icss[ix], "rollback");
00219 return(status);
00220 #else
00221 return(DBR_NOT_COMPILED_IN);
00222 #endif
00223 }
00224
00225 int dboIsConnected(int icss_index) {
00226 #if defined(DBR)
00227 if (dboLogSQL) rodsLog(LOG_SQL, "dboIsConnected");
00228 return(dbr_icss[icss_index].status);
00229 #else
00230 return(DBR_NOT_COMPILED_IN);
00231 #endif
00232 }
00233
00234
00235
00236
00237 int
00238 checkAccessToDBR(rsComm_t *rsComm, char *dbrName)
00239 {
00240 genQueryInp_t genQueryInp;
00241 genQueryOut_t *genQueryOut;
00242 int iAttr[10];
00243 int iAttrVal[10]={0,0,0,0,0};
00244 int iCond[10];
00245 char *condVal[10];
00246 char v1[BIG_STR];
00247 char v2[BIG_STR];
00248 char v3[BIG_STR];
00249 int status, i, j;
00250
00251 memset (&genQueryInp, 0, sizeof (genQueryInp_t));
00252
00253 i=0;
00254 iAttr[i++]=COL_RESC_ACCESS_NAME;
00255
00256 genQueryInp.selectInp.inx = iAttr;
00257 genQueryInp.selectInp.value = iAttrVal;
00258 genQueryInp.selectInp.len = i;
00259
00260 genQueryInp.sqlCondInp.inx = iCond;
00261 genQueryInp.sqlCondInp.value = condVal;
00262
00263 i=0;
00264 iCond[i]=COL_R_RESC_NAME;
00265 sprintf(v1,"='%s'",dbrName);
00266 condVal[i++]=v1;
00267
00268 iCond[i]=COL_RESC_USER_NAME;
00269 sprintf(v2,"='%s'", rsComm->clientUser.userName);
00270 condVal[i++]=v2;
00271
00272 iCond[i]=COL_RESC_USER_ZONE;
00273 sprintf(v3,"='%s'", rsComm->clientUser.rodsZone);
00274 condVal[i++]=v3;
00275
00276 genQueryInp.sqlCondInp.len=i;
00277
00278 genQueryInp.maxRows=50;
00279 genQueryInp.continueInx=0;
00280 status = rsGenQuery(rsComm, &genQueryInp, &genQueryOut);
00281 if (status == CAT_NO_ROWS_FOUND) return(0);
00282 if (status) return(status);
00283
00284 for (i=0;i<genQueryOut->rowCnt;i++) {
00285 for (j=0;j<genQueryOut->attriCnt;j++) {
00286 char *tResult;
00287 tResult = genQueryOut->sqlResult[j].value;
00288 tResult += i*genQueryOut->sqlResult[j].len;
00289 printf("%s ",tResult);
00290 if (strcmp(tResult,"own")==0) return(DBR_ACCESS_OWN);
00291 if (strcmp(tResult,"modify object")==0) return(DBR_ACCESS_WRITE);
00292 if (strcmp(tResult,"read object")==0) return(DBR_ACCESS_READ);
00293 }
00294 printf("\n");
00295 }
00296 return (0);
00297 }
00298
00299
00300
00301
00302
00303 int
00304 checkDBOType(rsComm_t *rsComm, char *dboName)
00305 {
00306 genQueryInp_t genQueryInp;
00307 genQueryOut_t *genQueryOut;
00308 int iAttr[10];
00309 int iAttrVal[10]={0,0,0,0,0};
00310 int iCond[10];
00311 char *condVal[10];
00312 char v1[BIG_STR];
00313 char v2[BIG_STR];
00314 char v3[BIG_STR];
00315 int status, i;
00316 char logicalFileName[MAX_NAME_LEN];
00317 char logicalDirName[MAX_NAME_LEN];
00318
00319 memset (&genQueryInp, 0, sizeof (genQueryInp_t));
00320
00321 i=0;
00322 iAttr[i++]=COL_D_DATA_ID;
00323
00324 genQueryInp.selectInp.inx = iAttr;
00325 genQueryInp.selectInp.value = iAttrVal;
00326 genQueryInp.selectInp.len = i;
00327
00328 genQueryInp.sqlCondInp.inx = iCond;
00329 genQueryInp.sqlCondInp.value = condVal;
00330
00331 status = splitPathByKey(dboName,
00332 logicalDirName, logicalFileName, '/');
00333
00334 i=0;
00335 iCond[i]=COL_DATA_TYPE_NAME;
00336 sprintf(v1,"='%s'","database object");
00337 condVal[i++]=v1;
00338
00339 iCond[i]=COL_DATA_NAME;
00340 sprintf(v2,"='%s'", logicalFileName);
00341 condVal[i++]=v2;
00342
00343 iCond[i]=COL_COLL_NAME;
00344 sprintf(v3,"='%s'", logicalDirName);
00345 condVal[i++]=v3;
00346
00347 genQueryInp.sqlCondInp.len=i;
00348
00349 genQueryInp.maxRows=50;
00350 genQueryInp.continueInx=0;
00351 status = rsGenQuery(rsComm, &genQueryInp, &genQueryOut);
00352 if (status == CAT_NO_ROWS_FOUND) return(DBO_NOT_VALID_DATATYPE);
00353 return(status);
00354 }
00355
00356
00357
00358
00359
00360 int checkDBOOwner(rsComm_t *rsComm, char *dbrName, char *dboName) {
00361 genQueryInp_t genQueryInp;
00362 genQueryOut_t *genQueryOut;
00363 genQueryInp_t genQueryInp2;
00364 genQueryOut_t *genQueryOut2;
00365 int iAttr[10];
00366 int iAttrVal[10]={0,0,0,0,0};
00367 int iCond[10];
00368 char *condVal[10];
00369 char v1[BIG_STR];
00370 char v2[BIG_STR];
00371 char v3[BIG_STR];
00372 int status, i, j;
00373 char logicalFileName[MAX_NAME_LEN];
00374 char logicalDirName[MAX_NAME_LEN];
00375
00376 memset (&genQueryInp, 0, sizeof (genQueryInp_t));
00377
00378 i=0;
00379 iAttr[i++]=COL_DATA_ACCESS_USER_ID;
00380
00381 genQueryInp.selectInp.inx = iAttr;
00382 genQueryInp.selectInp.value = iAttrVal;
00383 genQueryInp.selectInp.len = i;
00384
00385 status = splitPathByKey(dboName,
00386 logicalDirName, logicalFileName, '/');
00387
00388 i=0;
00389 iCond[i]=COL_DATA_ACCESS_NAME;
00390 sprintf(v1,"= '%s' || = '%s'","own", "modify object");
00391 condVal[i++]=v1;
00392
00393 iCond[i]=COL_DATA_NAME;
00394 sprintf(v2,"='%s'", logicalFileName);
00395 condVal[i++]=v2;
00396
00397 iCond[i]=COL_COLL_NAME;
00398 sprintf(v3,"='%s'", logicalDirName);
00399 condVal[i++]=v3;
00400
00401 genQueryInp.sqlCondInp.len=i;
00402 genQueryInp.sqlCondInp.inx = iCond;
00403 genQueryInp.sqlCondInp.value = condVal;
00404
00405 genQueryInp.maxRows=20;
00406 genQueryInp.continueInx=0;
00407 genQueryInp.condInput.len=0;
00408 status = rsGenQuery(rsComm, &genQueryInp, &genQueryOut);
00409 if (status) return(status);
00410 if (genQueryOut->continueInx != 0) return(DBR_WRITABLE_BY_TOO_MANY);
00411
00412 for (i=0;i<genQueryOut->rowCnt;i++) {
00413 printf("DEBUGy");
00414 for (j=0;j<genQueryOut->attriCnt;j++) {
00415 char *tResult;
00416 tResult = genQueryOut->sqlResult[j].value;
00417 tResult += i*genQueryOut->sqlResult[j].len;
00418 printf("%s ",tResult);
00419 }
00420 printf("\n");
00421 }
00422
00423
00424
00425 memset (&genQueryInp2, 0, sizeof (genQueryInp_t));
00426
00427 i=0;
00428 iAttr[i++]=COL_RESC_ACCESS_USER_ID;
00429
00430 genQueryInp2.selectInp.inx = iAttr;
00431 genQueryInp2.selectInp.value = iAttrVal;
00432 genQueryInp2.selectInp.len = i;
00433
00434 i=0;
00435 iCond[i]=COL_RESC_ACCESS_NAME;
00436 sprintf(v1,"= '%s'", "modify object");
00437 condVal[i++]=v1;
00438
00439 iCond[i]=COL_R_RESC_NAME;
00440 sprintf(v2,"='%s'", dbrName);
00441 condVal[i++]=v2;
00442
00443 genQueryInp2.sqlCondInp.len=i;
00444 genQueryInp2.sqlCondInp.inx = iCond;
00445 genQueryInp2.sqlCondInp.value = condVal;
00446
00447 genQueryInp2.maxRows=20;
00448 genQueryInp2.continueInx=0;
00449 genQueryInp2.condInput.len=0;
00450 status = rsGenQuery(rsComm, &genQueryInp2, &genQueryOut2);
00451
00452 if (status) return(status);
00453 if (genQueryOut2->continueInx != 0) return(DBR_WRITABLE_BY_TOO_MANY);
00454
00455 #if 0
00456 for (i=0;i<genQueryOut2->rowCnt;i++) {
00457 for (j=0;j<genQueryOut->attriCnt;j++) {
00458 char *tResult;
00459 tResult = genQueryOut->sqlResult[j].value;
00460 tResult += i*genQueryOut->sqlResult[j].len;
00461 printf("DEBUG2: %s ",tResult);
00462 }
00463 printf("\n");
00464 }
00465 #endif
00466
00467
00468
00469 if (genQueryOut->rowCnt > genQueryOut2->rowCnt)
00470 return(DBO_WRITABLE_BY_NON_PRIVILEGED);
00471
00472
00473
00474 for (i=0;i<genQueryOut->rowCnt;i++) {
00475 int OK=0;
00476 for (j=0;j<genQueryOut2->rowCnt;j++) {
00477 if (strcmp(genQueryOut->sqlResult[i].value,
00478 genQueryOut2->sqlResult[j].value) == 0) OK=1;
00479 }
00480 if (OK==0) return(DBO_WRITABLE_BY_NON_PRIVILEGED);
00481 }
00482 return (status);
00483 }
00484
00485
00486 int dboSqlNoResults(char *sql, char *parm[], int nParms) {
00487 #if defined(DBO_NOTYET)
00488 int i;
00489 for (i=0;i<nParms;i++) {
00490 cllBindVars[i]=parm[i];
00491 }
00492 cllBindVarCount=nParms;
00493 i = cllExecSqlNoResult(&dbr_icss, sql);
00494
00495 printf("i=%d\n",i);
00496 if (i==CAT_SUCCESS_BUT_WITH_NO_INFO) return(0);
00497 if (i) return(DBO_SQL_ERR);
00498 return(0);
00499 #else
00500 return(DBR_NOT_COMPILED_IN);
00501 #endif
00502 }
00503
00504 int dboSqlWithResults(int fd, char *sql, char *sqlFormat, char *args[10],
00505 char *outBuf, int maxOutBuf) {
00506 #if defined(DBR)
00507 int i, ii;
00508 int statement;
00509 int rowCount, nCols;
00510 int csvMode=0;
00511
00512 csvMode=0;
00513 if (strcmp(sqlFormat, "csv")==0) csvMode=1;
00514 if (strcmp(sqlFormat, "CSV")==0) csvMode=1;
00515
00516 for (i=0;i<10;i++) {
00517 if (args[i]==NULL || strlen(args[i])==0) break;
00518 cllBindVars[i]=args[i];
00519 }
00520 cllBindVarCount=i;
00521
00522 i = cllExecSqlWithResult(&dbr_icss[fd], &statement, sql);
00523 if (i==CAT_SUCCESS_BUT_WITH_NO_INFO) return(CAT_SUCCESS_BUT_WITH_NO_INFO);
00524 if (i) {
00525 cllGetLastErrorMessage(outBuf, maxOutBuf);
00526 if (i <= CAT_ENV_ERR) return(i);
00527 return (CAT_SQL_ERR);
00528 }
00529
00530 for (rowCount=0;;rowCount++) {
00531 i = cllGetRow(&dbr_icss[fd], statement);
00532 if (i != 0) {
00533 ii = cllFreeStatement(&dbr_icss[fd], statement);
00534 if (rowCount==0) return(CAT_GET_ROW_ERR);
00535 return(0);
00536 }
00537
00538 if (dbr_icss[fd].stmtPtr[statement]->numOfCols == 0) {
00539 i = cllFreeStatement(&dbr_icss[fd],statement);
00540 if (rowCount==0) return(CAT_NO_ROWS_FOUND);
00541 if (!csvMode) {
00542 rstrcat(outBuf, "\n<\\rows>\n", maxOutBuf);
00543 }
00544 else {
00545 rstrcat(outBuf, "\n", maxOutBuf);
00546 }
00547 return(0);
00548 }
00549
00550 nCols = dbr_icss[fd].stmtPtr[statement]->numOfCols;
00551 if (rowCount==0) {
00552 if (!csvMode) rstrcat(outBuf, "<column_descriptions>\n", maxOutBuf);
00553 for (i=0; i<nCols ; i++ ) {
00554 rstrcat(outBuf, dbr_icss[fd].stmtPtr[statement]->resultColName[i],
00555 maxOutBuf);
00556 if (csvMode) {
00557 if (i<nCols-1) {
00558 rstrcat(outBuf, ",", maxOutBuf);
00559 }
00560 else {
00561 rstrcat(outBuf, "\n", maxOutBuf);
00562 }
00563 }
00564 else {
00565 rstrcat(outBuf, "|", maxOutBuf);
00566 }
00567 }
00568 if (!csvMode) {
00569 rstrcat(outBuf, "\n<\\column_descriptions>\n<rows>\n", maxOutBuf);
00570 }
00571 }
00572 if (rowCount>0) rstrcat(outBuf, "\n", maxOutBuf);
00573 if (nCols>0 && nCols<11 && sqlFormat!=NULL && *sqlFormat!='\0'
00574 && csvMode==0 ) {
00575 char line1[1000];
00576 if (nCols==1) {
00577 snprintf(line1, sizeof(line1), sqlFormat,
00578 dbr_icss[fd].stmtPtr[statement]->resultValue[0]);
00579 }
00580 if (nCols==2) {
00581 snprintf(line1, sizeof(line1), sqlFormat,
00582 dbr_icss[fd].stmtPtr[statement]->resultValue[0],
00583 dbr_icss[fd].stmtPtr[statement]->resultValue[1]);
00584 }
00585 if (nCols==3) {
00586 snprintf(line1, sizeof(line1), sqlFormat,
00587 dbr_icss[fd].stmtPtr[statement]->resultValue[0],
00588 dbr_icss[fd].stmtPtr[statement]->resultValue[1],
00589 dbr_icss[fd].stmtPtr[statement]->resultValue[2]);
00590 }
00591 if (nCols==4) {
00592 snprintf(line1, sizeof(line1), sqlFormat,
00593 dbr_icss[fd].stmtPtr[statement]->resultValue[0],
00594 dbr_icss[fd].stmtPtr[statement]->resultValue[1],
00595 dbr_icss[fd].stmtPtr[statement]->resultValue[2],
00596 dbr_icss[fd].stmtPtr[statement]->resultValue[3]);
00597 }
00598 if (nCols==5) {
00599 snprintf(line1, sizeof(line1), sqlFormat,
00600 dbr_icss[fd].stmtPtr[statement]->resultValue[0],
00601 dbr_icss[fd].stmtPtr[statement]->resultValue[1],
00602 dbr_icss[fd].stmtPtr[statement]->resultValue[2],
00603 dbr_icss[fd].stmtPtr[statement]->resultValue[3],
00604 dbr_icss[fd].stmtPtr[statement]->resultValue[4]);
00605 }
00606 if (nCols==6) {
00607 snprintf(line1, sizeof(line1), sqlFormat,
00608 dbr_icss[fd].stmtPtr[statement]->resultValue[0],
00609 dbr_icss[fd].stmtPtr[statement]->resultValue[1],
00610 dbr_icss[fd].stmtPtr[statement]->resultValue[2],
00611 dbr_icss[fd].stmtPtr[statement]->resultValue[3],
00612 dbr_icss[fd].stmtPtr[statement]->resultValue[4],
00613 dbr_icss[fd].stmtPtr[statement]->resultValue[5]);
00614 }
00615 if (nCols==7) {
00616 snprintf(line1, sizeof(line1), sqlFormat,
00617 dbr_icss[fd].stmtPtr[statement]->resultValue[0],
00618 dbr_icss[fd].stmtPtr[statement]->resultValue[1],
00619 dbr_icss[fd].stmtPtr[statement]->resultValue[2],
00620 dbr_icss[fd].stmtPtr[statement]->resultValue[3],
00621 dbr_icss[fd].stmtPtr[statement]->resultValue[4],
00622 dbr_icss[fd].stmtPtr[statement]->resultValue[5],
00623 dbr_icss[fd].stmtPtr[statement]->resultValue[6]);
00624 }
00625 if (nCols==8) {
00626 snprintf(line1, sizeof(line1), sqlFormat,
00627 dbr_icss[fd].stmtPtr[statement]->resultValue[0],
00628 dbr_icss[fd].stmtPtr[statement]->resultValue[1],
00629 dbr_icss[fd].stmtPtr[statement]->resultValue[2],
00630 dbr_icss[fd].stmtPtr[statement]->resultValue[3],
00631 dbr_icss[fd].stmtPtr[statement]->resultValue[4],
00632 dbr_icss[fd].stmtPtr[statement]->resultValue[5],
00633 dbr_icss[fd].stmtPtr[statement]->resultValue[6],
00634 dbr_icss[fd].stmtPtr[statement]->resultValue[7]);
00635 }
00636 if (nCols==9) {
00637 snprintf(line1, sizeof(line1), sqlFormat,
00638 dbr_icss[fd].stmtPtr[statement]->resultValue[0],
00639 dbr_icss[fd].stmtPtr[statement]->resultValue[1],
00640 dbr_icss[fd].stmtPtr[statement]->resultValue[2],
00641 dbr_icss[fd].stmtPtr[statement]->resultValue[3],
00642 dbr_icss[fd].stmtPtr[statement]->resultValue[4],
00643 dbr_icss[fd].stmtPtr[statement]->resultValue[5],
00644 dbr_icss[fd].stmtPtr[statement]->resultValue[6],
00645 dbr_icss[fd].stmtPtr[statement]->resultValue[7],
00646 dbr_icss[fd].stmtPtr[statement]->resultValue[8]);
00647 }
00648 if (nCols==10) {
00649 snprintf(line1, sizeof(line1), sqlFormat,
00650 dbr_icss[fd].stmtPtr[statement]->resultValue[0],
00651 dbr_icss[fd].stmtPtr[statement]->resultValue[1],
00652 dbr_icss[fd].stmtPtr[statement]->resultValue[2],
00653 dbr_icss[fd].stmtPtr[statement]->resultValue[3],
00654 dbr_icss[fd].stmtPtr[statement]->resultValue[4],
00655 dbr_icss[fd].stmtPtr[statement]->resultValue[5],
00656 dbr_icss[fd].stmtPtr[statement]->resultValue[6],
00657 dbr_icss[fd].stmtPtr[statement]->resultValue[7],
00658 dbr_icss[fd].stmtPtr[statement]->resultValue[8],
00659 dbr_icss[fd].stmtPtr[statement]->resultValue[9]);
00660 }
00661 rstrcat(outBuf, line1, maxOutBuf);
00662 }
00663 else {
00664 for (i=0; i<nCols ; i++ ) {
00665 rstrcat(outBuf, dbr_icss[fd].stmtPtr[statement]->resultValue[i],
00666 maxOutBuf);
00667 if (csvMode) {
00668 if (i<nCols-1) {
00669 rstrcat(outBuf, ",", maxOutBuf);
00670 }
00671 }
00672 else {
00673 rstrcat(outBuf, "|", maxOutBuf);
00674 }
00675 }
00676 }
00677 }
00678
00679 return(0);
00680 #else
00681 return(DBR_NOT_COMPILED_IN);
00682 #endif
00683 }
00684
00685 char *
00686 getDbrConfigDir()
00687 {
00688 char *myDir;
00689
00690 if ((myDir = (char *) getenv("irodsConfigDir")) != (char *) NULL) {
00691 return (myDir);
00692 }
00693 return (DEF_CONFIG_DIR);
00694 }
00695
00696 int
00697 readDbrConfig(char *dboName, char *DBUser, char *DBPasswd, char *DBType) {
00698 FILE *fptr;
00699 char buf[BUF_LEN];
00700 char *fchar;
00701 char *key;
00702 char *dboConfigFile;
00703 char foundLine[BUF_LEN];
00704 int state, i;
00705 char *DBKey=0;
00706 int f1=0, f2=0, f3=0, f4=0;
00707
00708 dboConfigFile = (char *) malloc((strlen (getDbrConfigDir()) +
00709 strlen(DBR_CONFIG_FILE) + 24));
00710
00711 sprintf (dboConfigFile, "%s/%s", getDbrConfigDir(),
00712 DBR_CONFIG_FILE);
00713
00714 fptr = fopen (dboConfigFile, "r");
00715
00716 if (fptr == NULL) {
00717 rodsLog (LOG_NOTICE,
00718 "Cannot open DBR_CONFIG_FILE file %s. errno = %d\n",
00719 dboConfigFile, errno);
00720 free (dboConfigFile);
00721 return (DBR_CONFIG_FILE_ERR);
00722 }
00723 free (dboConfigFile);
00724
00725 buf[BUF_LEN-1]='\0';
00726 fchar = fgets(buf, BUF_LEN-1, fptr);
00727 for(;fchar!='\0';) {
00728 if (buf[0]=='#' || buf[0]=='/') {
00729 buf[0]='\0';
00730 }
00731 key=strstr(buf, dboName);
00732 if (key == buf) {
00733 rstrcpy(foundLine, buf, BUF_LEN);
00734 state=0;
00735 for (i=0;i<BUF_LEN;i++) {
00736 if (foundLine[i]==' ' || foundLine[i]=='\n') {
00737 int endOfLine;
00738 endOfLine=0;
00739 if (foundLine[i]=='\n') endOfLine=1;
00740 foundLine[i]='\0';
00741 if (endOfLine && state<8) break;
00742 if (state==0) state=1;
00743 if (state==2) state=3;
00744 if (state==4) state=5;
00745 if (state==6) state=7;
00746 if (state==8) {
00747 break;
00748 }
00749 }
00750 else {
00751 if (state==1) {
00752 state=2;
00753 f1 = i;
00754 }
00755 if (state==3) {
00756 state=4;
00757 f2 = i;
00758 }
00759 if (state==5) {
00760 state=6;
00761 f3 = i;
00762 }
00763 if (state==7) {
00764 state=8;
00765 f4 = i;
00766 }
00767 }
00768 }
00769 if (f4>0) {
00770 static char unscrambledPw[DB_PASSWORD_LEN];
00771 DBKey=&foundLine[f4];
00772 obfDecodeByKey(DBPasswd, DBKey, unscrambledPw);
00773 strncpy(DBPasswd,unscrambledPw,DB_PASSWORD_LEN);
00774 }
00775 if (f3>0) {
00776 strncpy(DBType,&foundLine[i],DB_TYPENAME_LEN);
00777 }
00778 if (f2>0) {
00779 strncpy(DBPasswd,&foundLine[f2],DB_PASSWORD_LEN);
00780 }
00781 if (f1>0) {
00782 strncpy(DBUser,&foundLine[f1],DB_USERNAME_LEN);
00783 fclose (fptr);
00784 return(0);
00785 }
00786 }
00787 fchar = fgets(buf, BUF_LEN-1, fptr);
00788 }
00789 fclose (fptr);
00790
00791 return(DBR_NAME_NOT_FOUND);
00792 }
00793
00794 int
00795 getDboSql( rsComm_t *rsComm, char *fullName, char *dboSQL, char *dboFormat) {
00796 openedDataObjInp_t dataObjReadInp;
00797 openedDataObjInp_t dataObjCloseInp;
00798 bytesBuf_t *readBuf;
00799 int status;
00800 int objFD;
00801 char *cp1, *cp2, *cp3;
00802 int bytesRead;
00803 dataObjInp_t dataObjInp;
00804
00805 memset (&dataObjInp, 0, sizeof(dataObjInp_t));
00806 rstrcpy(dataObjInp.objPath, fullName, MAX_NAME_LEN);
00807
00808 if ((objFD=rsDataObjOpen(rsComm, &dataObjInp)) < 0) {
00809 int i;
00810 if (objFD == CAT_NO_ROWS_FOUND) return (DBO_DOES_NOT_EXIST);
00811 if (objFD==CAT_NO_ACCESS_PERMISSION) {
00812 i = addRErrorMsg (&rsComm->rError, 0,
00813 "You do not have read access to the DBO.");
00814 }
00815 return (objFD);
00816 }
00817
00818
00819 readBuf = (bytesBuf_t *)malloc(sizeof(bytesBuf_t));
00820 readBuf->len = 5*1024;
00821 readBuf->buf = (char *)malloc(readBuf->len);
00822 memset (readBuf->buf, '\0', readBuf->len);
00823
00824
00825 memset (&dataObjReadInp, 0, sizeof (dataObjReadInp));
00826 dataObjReadInp.l1descInx = objFD;
00827 dataObjReadInp.len = readBuf->len;
00828
00829 bytesRead = rsDataObjRead (rsComm, &dataObjReadInp, readBuf);
00830 if (bytesRead < 0) return(bytesRead);
00831
00832
00833 cp1 = (char*)readBuf->buf;
00834
00835 while (*cp1 == '!' || *cp1 == '#') {
00836 cp1++;
00837 while (*cp1 != '\n') cp1++;
00838 cp1++;
00839 }
00840 cp2=cp1;
00841 while (*cp2 != '\n' && *cp2 != '\0') cp2++;
00842 if (*cp2=='\0') {
00843 rstrcpy(dboSQL, cp1, MAX_SQL);
00844 *dboFormat='\0';
00845 }
00846 else {
00847 *cp2='\0';
00848 rstrcpy(dboSQL, cp1, MAX_SQL);
00849 cp2++;
00850 cp3=cp2;
00851 while (*cp3 != '\n' && *cp3 != '\0') cp3++;
00852 *cp3='\0';
00853 rstrcpy(dboFormat, cp2, MAX_SQL);
00854 }
00855
00856 memset (&dataObjCloseInp, 0, sizeof (dataObjCloseInp));
00857 dataObjCloseInp.l1descInx = objFD;
00858
00859 free(readBuf);
00860
00861 status = rsDataObjClose (rsComm, &dataObjCloseInp);
00862 if (status) return(status);
00863
00864 return(0);
00865 }
00866
00867 void
00868 printSqlAndArgsEtc(char *dbrName,
00869 char *dboSQL, char *args[10], char *outBuf, int maxOutBuf) {
00870 int i;
00871 rstrcpy(outBuf, "<dbr>", maxOutBuf);
00872 rstrcat(outBuf, dbrName, maxOutBuf);
00873 rstrcat(outBuf, "</dbr>\n", maxOutBuf);
00874 rstrcat(outBuf, "<sql>", maxOutBuf);
00875 rstrcat(outBuf, dboSQL, maxOutBuf);
00876 rstrcat(outBuf, "</sql>\n", maxOutBuf);
00877 for (i=0;i<10;i++) {
00878 if (args[i]==NULL || strlen(args[i])==0) break;
00879 rstrcat(outBuf, "<arg>", maxOutBuf);
00880 rstrcat(outBuf, args[i], maxOutBuf);
00881 rstrcat(outBuf, "</arg>\n", maxOutBuf);
00882 }
00883 }
00884
00885 int
00886 openDBOR(rsComm_t *rsComm, char *dborName, int forceOption) {
00887 dataObjInp_t myDataObjInp;
00888 int status;
00889
00890 memset (&myDataObjInp, 0, sizeof(dataObjInp_t));
00891 rstrcpy(myDataObjInp.objPath, dborName, MAX_NAME_LEN);
00892 if (forceOption) {
00893 addKeyVal (&myDataObjInp.condInput, FORCE_FLAG_KW, "");
00894 }
00895 status = rsDataObjCreate (rsComm, &myDataObjInp);
00896 return(status);
00897 }
00898
00899 int
00900 dboExecute(rsComm_t *rsComm, char *dbrName, char *dboName,
00901 char *dborName, int dborOption,
00902 char *outBuf,
00903 int maxOutBuf, char *args[10]) {
00904 int status;
00905 char dboSQL[MAX_SQL];
00906 char dboFormat[MAX_SQL];
00907 int i, ix;
00908 int outBufStrLen;
00909 int didOpen=0;
00910 int dbrAccess;
00911 int outDesc;
00912 char *myOutBuf;
00913 int myMaxOutBuf;
00914 int csvMode;
00915
00916 myOutBuf = outBuf;
00917 myMaxOutBuf = maxOutBuf;
00918
00919 status = checkDBOType(rsComm, dboName);
00920 if (status==DBO_NOT_VALID_DATATYPE) {
00921 int i;
00922 i = addRErrorMsg (&rsComm->rError, 0,
00923 "Either the DBO does not exist or does not have a data-type\nof 'database object'. The owner of the DBO can set the datatype via 'isysmeta'.\nSee 'isysmeta -h'.");
00924 }
00925 if (status) return(status);
00926
00927 dbrAccess = checkAccessToDBR(rsComm, dbrName);
00928 if (dbrAccess < 0) return(dbrAccess);
00929
00930 if (dbrAccess < DBR_ACCESS_WRITE) {
00931 if (dbrAccess == DBR_ACCESS_READ) {
00932 status = checkDBOOwner(rsComm, dbrName, dboName);
00933 if (status==DBO_WRITABLE_BY_NON_PRIVILEGED) {
00934 int i;
00935 i = addRErrorMsg (&rsComm->rError, 0,
00936 "The DBO is not secure. Some users who can write to the DBO do not have write permission to the DBR.");
00937 }
00938 if (status) return(status);
00939 }
00940 else {
00941 return (DBR_ACCESS_PROHIBITED);
00942 }
00943 }
00944
00945 if (dborName != NULL && *dborName!='\0') {
00946 outDesc=openDBOR(rsComm, dborName, dborOption);
00947 if (outDesc < 0) return(outDesc);
00948
00949
00950
00951
00952
00953
00954 myMaxOutBuf = LOCAL_BUFFER_SIZE;
00955 myOutBuf=(char *)malloc(myMaxOutBuf);
00956 }
00957 else {
00958 outDesc = -1;
00959 }
00960
00961 ix=getOpenDbrIndex(dbrName);
00962
00963 if (ix < 0) {
00964 ix = dbrOpen(dbrName);
00965 if (ix) { free( myOutBuf ); return(ix); }
00966 didOpen=1;
00967 }
00968
00969 status = getDboSql(rsComm, dboName, dboSQL, dboFormat);
00970 if (status) { free( myOutBuf ); return(status); }
00971
00972 if (dboLogSQL) rodsLog(LOG_SQL, "dboExecute SQL: %s\n", dboSQL);
00973
00974 csvMode=0;
00975 if (strcmp(dboFormat, "csv")==0) csvMode=1;
00976 if (strcmp(dboFormat, "CSV")==0) csvMode=1;
00977
00978 if (!csvMode) {
00979 printSqlAndArgsEtc(dbrName, dboSQL, args, myOutBuf, myMaxOutBuf);
00980 }
00981
00982 outBufStrLen = strlen(myOutBuf);
00983
00984 status = dboSqlWithResults(ix, dboSQL, dboFormat, args,
00985 myOutBuf+outBufStrLen, myMaxOutBuf-outBufStrLen-1);
00986
00987 if (status) {
00988 if (didOpen) {
00989 i = dbrClose(dbrName);
00990 }
00991 return(status);
00992 }
00993
00994 if (outDesc > 0) {
00995 openedDataObjInp_t dataObjWriteInp;
00996 int bytesWritten;
00997 openedDataObjInp_t dataObjCloseInp;
00998
00999 bytesBuf_t *writeBuf;
01000 writeBuf = (bytesBuf_t *)malloc(sizeof(bytesBuf_t));
01001 outBufStrLen = strlen(myOutBuf);
01002 writeBuf->len = outBufStrLen;
01003 writeBuf->buf = myOutBuf;
01004
01005 memset (&dataObjWriteInp, 0, sizeof (dataObjWriteInp));
01006 dataObjWriteInp.l1descInx = outDesc;
01007 dataObjWriteInp.len = outBufStrLen;
01008
01009 bytesWritten = rsDataObjWrite(rsComm, &dataObjWriteInp, writeBuf);
01010 if (bytesWritten < 0) return(bytesWritten);
01011
01012 if (bytesWritten != outBufStrLen) {
01013
01014 }
01015
01016 memset (&dataObjCloseInp, 0, sizeof (dataObjCloseInp));
01017 dataObjCloseInp.l1descInx = outDesc;
01018 status = rsDataObjClose (rsComm, &dataObjCloseInp);
01019 if (status) return(status);
01020
01021 rstrcpy(outBuf, "Output written to ", maxOutBuf);
01022 rstrcat(outBuf, dborName, maxOutBuf);
01023 rstrcat(outBuf, "\n", maxOutBuf);
01024
01025 free(myOutBuf);
01026 free(writeBuf);
01027 }
01028
01029 if (didOpen) {
01030 i = dbrClose(dbrName);
01031 if (i) return(i);
01032 }
01033 return(0);
01034 }