00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028 #include "rods.h"
00029 #include "rcMisc.h"
00030
00031 #include "rdaHighLevelRoutines.h"
00032 #include "icatLowLevel.h"
00033
00034 #include "icatHighLevelRoutines.h"
00035
00036
00037
00038
00039
00040 #define RDA_CONFIG_FILE "rda.config"
00041 #define RDA_ACCESS_ATTRIBUTE "RDA_ACCESS"
00042
00043 #define BUF_LEN 500
00044
00045 #define MAX_RDA_NAME_LEN 200
00046 #define BIG_STR 200
00047
00048 #define RESULT_BUF1_SIZE 2000
00049
00050 static char openRdaName[MAX_RDA_NAME_LEN+2]="";
00051
00052 int rdaLogSQL=0;
00053 int readRdaConfig(char *rdaName, char **DBUser, char**DBPasswd);
00054
00055 icatSessionStruct rda_icss={0};
00056
00057 int rdaDebug(char *debugMode) {
00058 if (strstr(debugMode, "SQL")) {
00059 rdaLogSQL=1;
00060 }
00061 else {
00062 rdaLogSQL=0;
00063 }
00064 return(0);
00065 }
00066
00067
00068
00069 int rdaOpen(char *rdaName) {
00070 #if defined(BUILD_RDA)
00071 int i;
00072 int status;
00073 char *DBUser;
00074 char *DBPasswd;
00075
00076 if (rdaLogSQL) rodsLog(LOG_SQL, "rdaOpen");
00077
00078 if (strcmp(openRdaName, rdaName)==0) {
00079 return(0);
00080 }
00081
00082 status = readRdaConfig(rdaName, &DBUser, &DBPasswd);
00083 if (status) return(status);
00084
00085 strncpy(rda_icss.databaseUsername, DBUser, DB_USERNAME_LEN);
00086 strncpy(rda_icss.databasePassword, DBPasswd, DB_PASSWORD_LEN);
00087
00088
00089 for (i=0; i<MAX_NUM_OF_CONCURRENT_STMTS; i++) {
00090 rda_icss.stmtPtr[i]=0;
00091 }
00092
00093
00094
00095
00096
00097
00098
00099 rda_icss->databaseType = DB_TYPE_POSTGRES;
00100 #ifdef ORA_ICAT
00101 rda_icss->databaseType = DB_TYPE_ORACLE;
00102 #endif
00103 #ifdef MY_ICAT
00104 rda_icss->databaseType = DB_TYPE_MYSQL;
00105 #endif
00106
00107
00108 i = cllOpenEnv(&rda_icss);
00109 if (i != 0) {
00110 rodsLog(LOG_NOTICE, "rdaOpen cllOpen failure %d",i);
00111 return(RDA_ENV_ERR);
00112 }
00113
00114
00115 i = cllConnectRda(&rda_icss);
00116 if (i != 0) {
00117 rodsLog(LOG_NOTICE, "rdaOpen cllConnectRda failure %d",i);
00118 return(RDA_CONNECT_ERR);
00119 }
00120
00121 rda_icss.status=1;
00122 strncmp(openRdaName, rdaName, MAX_RDA_NAME_LEN);
00123
00124 return(0);
00125 #else
00126 openRdaName[0]='\0';
00127 return(RDA_NOT_COMPILED_IN);
00128 #endif
00129 }
00130
00131 int rdaClose() {
00132 #if defined(BUILD_RDA)
00133 int status, stat2;
00134
00135 status = cllDisconnect(&rda_icss);
00136
00137 stat2 = cllCloseEnv(&rda_icss);
00138
00139 openRdaName[0]='\0';
00140
00141 if (status) {
00142 return(RDA_DISCONNECT_ERR);
00143 }
00144 if (stat2) {
00145 return(RDA_CLOSE_ENV_ERR);
00146 }
00147 rda_icss.status=0;
00148 return(0);
00149 #else
00150 return(RDA_NOT_COMPILED_IN);
00151 #endif
00152 }
00153
00154 int rdaCommit() {
00155 #if defined(BUILD_RDA)
00156 int status;
00157
00158 status = cllExecSqlNoResult(&rda_icss, "commit");
00159 return(status);
00160 #else
00161 return(RDA_NOT_COMPILED_IN);
00162 #endif
00163 }
00164
00165 int rdaRollback() {
00166 #if defined(BUILD_RDA)
00167 int status;
00168
00169 status = cllExecSqlNoResult(&rda_icss, "rollback");
00170 return(status);
00171 #else
00172 return(RDA_NOT_COMPILED_IN);
00173 #endif
00174 }
00175
00176 int rdaIsConnected() {
00177 #if defined(BUILD_RDA)
00178 if (rdaLogSQL) rodsLog(LOG_SQL, "rdaIsConnected");
00179 return(rda_icss.status);
00180 #else
00181 return(RDA_NOT_COMPILED_IN);
00182 #endif
00183 }
00184
00185
00186
00187
00188
00189 int rdaCheckAccess(char *rdaName, rsComm_t *rsComm) {
00190 #if defined(BUILD_RDA)
00191 genQueryInp_t genQueryInp;
00192 genQueryOut_t genQueryOut;
00193 int iAttr[10];
00194 int iAttrVal[10]={0,0,0,0,0};
00195 int iCond[10];
00196 char *condVal[10];
00197 char v1[BIG_STR];
00198 char v2[BIG_STR];
00199 char v3[BIG_STR];
00200 int status;
00201
00202 memset (&genQueryInp, 0, sizeof (genQueryInp_t));
00203
00204 iAttr[0]=COL_META_USER_ATTR_VALUE;
00205 genQueryInp.selectInp.inx = iAttr;
00206 genQueryInp.selectInp.value = iAttrVal;
00207 genQueryInp.selectInp.len = 1;
00208
00209 iCond[0]=COL_USER_NAME;
00210 sprintf(v1,"='%s'", rsComm->clientUser.userName);
00211 condVal[0]=v1;
00212
00213 iCond[1]=COL_META_USER_ATTR_NAME;
00214 sprintf(v2,"='%s'", RDA_ACCESS_ATTRIBUTE);
00215 condVal[1]=v2;
00216
00217 iCond[2]=COL_META_USER_ATTR_VALUE;
00218 sprintf(v3,"='%s'", rdaName);
00219 condVal[2]=v3;
00220
00221 genQueryInp.sqlCondInp.inx = iCond;
00222 genQueryInp.sqlCondInp.value = condVal;
00223 genQueryInp.sqlCondInp.len=3;
00224
00225 genQueryInp.maxRows=10;
00226 genQueryInp.continueInx=0;
00227 genQueryInp.condInput.len=0;
00228 status = chlGenQuery(genQueryInp, &genQueryOut);
00229 if (status == CAT_NO_ROWS_FOUND) {
00230 return(RDA_ACCESS_PROHIBITED);
00231 }
00232
00233 return (status);
00234 #else
00235 return(RDA_NOT_COMPILED_IN);
00236 #endif
00237 }
00238
00239
00240 int rdaSqlNoResults(char *sql, char *parm[], int nParms) {
00241 #if defined(BUILD_RDA)
00242 int i;
00243 for (i=0;i<nParms;i++) {
00244 cllBindVars[i]=parm[i];
00245 }
00246 cllBindVarCount=nParms;
00247 i = cllExecSqlNoResult(&rda_icss, sql);
00248
00249 printf("i=%d\n",i);
00250 if (i==CAT_SUCCESS_BUT_WITH_NO_INFO) return(0);
00251 if (i) return(RDA_SQL_ERR);
00252 return(0);
00253 #else
00254 return(RDA_NOT_COMPILED_IN);
00255 #endif
00256 }
00257
00258 int rdaSqlWithResults(char *sql, char *parm[], int nParms, char **outBuf) {
00259 #if defined(BUILD_RDA)
00260 int i, ii;
00261 int statement;
00262 int rowCount, nCols, rowSize=0;
00263 int maxOutBuf;
00264 char *myBuf, *pbuf;
00265 static char resultBuf1[RESULT_BUF1_SIZE+10];
00266 int totalRows, toMalloc;
00267
00268 for (i=0;i<nParms;i++) {
00269 cllBindVars[i]=parm[i];
00270 }
00271 cllBindVarCount=nParms;
00272 i = cllExecSqlWithResult(&rda_icss, &statement, sql);
00273 printf("i=%d\n",i);
00274
00275 if (i) return(RDA_SQL_ERR);
00276
00277 myBuf=resultBuf1;
00278 maxOutBuf=RESULT_BUF1_SIZE;
00279 memset(myBuf, 0, maxOutBuf);
00280
00281 for (rowCount=0;;rowCount++) {
00282 i = cllGetRow(&rda_icss, statement);
00283 if (i != 0) {
00284 ii = cllFreeStatement(&rda_icss, statement);
00285 if (rowCount==0) return(CAT_GET_ROW_ERR);
00286 *outBuf=myBuf;
00287 return(0);
00288 }
00289
00290 if (rda_icss.stmtPtr[statement]->numOfCols == 0) {
00291 i = cllFreeStatement(&rda_icss,statement);
00292 if (rowCount==0) return(CAT_NO_ROWS_FOUND);
00293 *outBuf=myBuf;
00294 return(0);
00295 }
00296
00297 nCols = rda_icss.stmtPtr[statement]->numOfCols;
00298 if (rowCount==0) {
00299 for (i=0; i<nCols ; i++ ) {
00300 rstrcat(myBuf, rda_icss.stmtPtr[statement]->resultColName[i],
00301 maxOutBuf);
00302 rstrcat(myBuf, "|", maxOutBuf);
00303 }
00304 rstrcat(myBuf, "\n", maxOutBuf);
00305 }
00306 for (i=0; i<nCols ; i++ ) {
00307 rstrcat(myBuf, rda_icss.stmtPtr[statement]->resultValue[i],
00308 maxOutBuf);
00309 rstrcat(myBuf, "|", maxOutBuf);
00310 }
00311 rstrcat(myBuf, "\n", maxOutBuf);
00312 if (rowSize==0) {
00313 rowSize=strlen(myBuf);
00314 totalRows=cllGetRowCount(&rda_icss, statement);
00315 printf("rowSize=%d, totalRows=%d\n",rowSize, totalRows);
00316 if (totalRows < 0) return(totalRows);
00317 if (totalRows == 0) {
00318
00319 totalRows=10;
00320 }
00321 toMalloc=((totalRows+1)*rowSize)*3;
00322 myBuf=malloc(toMalloc);
00323 if (myBuf <=0) { free( myBuf ); return(SYS_MALLOC_ERR); }
00324 maxOutBuf=toMalloc;
00325 memset(myBuf, 0, maxOutBuf);
00326 rstrcpy(myBuf, resultBuf1, RESULT_BUF1_SIZE);
00327 }
00328 if (rowCount > totalRows) {
00329 int oldTotalRows;
00330 oldTotalRows = totalRows;
00331 if (totalRows < 1000) {
00332 totalRows = totalRows*2;
00333 }
00334 else {
00335 totalRows = totalRows+500;
00336 }
00337 pbuf = myBuf;
00338 toMalloc=((totalRows+1)*rowSize)*3;
00339 myBuf=malloc(toMalloc);
00340 if (myBuf <=0) { free( myBuf ); return(SYS_MALLOC_ERR); }
00341 maxOutBuf=toMalloc;
00342 memset(myBuf, 0, maxOutBuf);
00343 strcpy(myBuf, pbuf);
00344 free(pbuf);
00345 }
00346 }
00347
00348 return(0);
00349 #else
00350 return(RDA_NOT_COMPILED_IN);
00351 #endif
00352 }
00353
00354 char *
00355 getRdaConfigDir()
00356 {
00357 char *myDir;
00358
00359 if ((myDir = (char *) getenv("irodsConfigDir")) != (char *) NULL) {
00360 return (myDir);
00361 }
00362 return (DEF_CONFIG_DIR);
00363 }
00364
00365 int
00366 readRdaConfig(char *rdaName, char **DBUser, char**DBPasswd) {
00367 FILE *fptr;
00368 char buf[BUF_LEN];
00369 char *fchar;
00370 char *key;
00371 char *rdaConfigFile;
00372 static char foundLine[BUF_LEN];
00373
00374 rdaConfigFile = (char *) malloc((strlen (getRdaConfigDir()) +
00375 strlen(RDA_CONFIG_FILE) + 24));
00376
00377 sprintf (rdaConfigFile, "%s/%s", getRdaConfigDir(),
00378 RDA_CONFIG_FILE);
00379
00380 fptr = fopen (rdaConfigFile, "r");
00381
00382 if (fptr == NULL) {
00383 rodsLog (LOG_NOTICE,
00384 "Cannot open RDA_CONFIG_FILE file %s. errno = %d\n",
00385 rdaConfigFile, errno);
00386 free (rdaConfigFile);
00387 return (RDA_CONFIG_FILE_ERR);
00388 }
00389 free (rdaConfigFile);
00390
00391 buf[BUF_LEN-1]='\0';
00392 fchar = fgets(buf, BUF_LEN-1, fptr);
00393 for(;fchar!='\0';) {
00394 if (buf[0]=='#' || buf[0]=='/') {
00395 buf[0]='\0';
00396 }
00397 key=strstr(buf, rdaName);
00398 if (key == buf) {
00399 int state, i;
00400 char *DBKey=0;
00401 rstrcpy(foundLine, buf, BUF_LEN);
00402 state=0;
00403 for (i=0;i<BUF_LEN;i++) {
00404 if (foundLine[i]==' ' || foundLine[i]=='\n') {
00405 int endOfLine;
00406 endOfLine=0;
00407 if (foundLine[i]=='\n') endOfLine=1;
00408 foundLine[i]='\0';
00409 if (endOfLine && state<6) {
00410 fclose( fptr );
00411 return(0);
00412 }
00413 if (state==0) state=1;
00414 if (state==2) state=3;
00415 if (state==4) state=5;
00416 if (state==6) {
00417 static char unscrambledPw[NAME_LEN];
00418 obfDecodeByKey(*DBPasswd, DBKey, unscrambledPw);
00419 *DBPasswd=unscrambledPw;
00420 fclose( fptr );
00421 return(0);
00422 }
00423 }
00424 else {
00425 if (state==1) {
00426 state=2;
00427 *DBUser=&foundLine[i];
00428 }
00429 if (state==3) {
00430 state=4;
00431 *DBPasswd=&foundLine[i];
00432 }
00433 if (state==5) {
00434 state=6;
00435 DBKey=&foundLine[i];
00436 }
00437 }
00438 }
00439 }
00440 fchar = fgets(buf, BUF_LEN-1, fptr);
00441 }
00442 fclose (fptr);
00443
00444 return(RDA_NAME_NOT_FOUND);
00445 }