自学教程：C++ rsGenQuery函数代码示例

intisColl( rsComm_t *rsComm, char *objName, rodsLong_t *collId ) {    genQueryInp_t genQueryInp;    genQueryOut_t *genQueryOut = NULL;    char tmpStr[MAX_NAME_LEN];    int status;    memset( &genQueryInp, 0, sizeof( genQueryInp_t ) );    snprintf( tmpStr, MAX_NAME_LEN, "='%s'", objName );    addInxVal( &genQueryInp.sqlCondInp, COL_COLL_NAME, tmpStr );    addInxIval( &genQueryInp.selectInp, COL_COLL_ID, 1 );    genQueryInp.maxRows = 2;    status =  rsGenQuery( rsComm, &genQueryInp, &genQueryOut );    if ( status >= 0 ) {        sqlResult_t *collIdRes;        if ( ( collIdRes = getSqlResultByInx( genQueryOut, COL_COLL_ID ) ) ==                NULL ) {            rodsLog( LOG_ERROR,                     "isColl: getSqlResultByInx for COL_D_DATA_ID failed" );            return UNMATCHED_KEY_OR_INDEX;        }        if ( collId != NULL ) {            *collId = strtoll( collIdRes->value, 0, 0 );        }        freeGenQueryOut( &genQueryOut );    }    clearGenQueryInp( &genQueryInp );    return status;}

intcheckPermitForDataObject( rsComm_t *rsComm, char *objName, int userId, int operId ) {    genQueryInp_t genQueryInp;    genQueryOut_t *genQueryOut = NULL;    char t1[MAX_NAME_LEN]; // JMC cppcheck - snprintf out of bounds    char t11[MAX_NAME_LEN]; // JMC cppcheck - snprintf out of bounds    char t2[MAX_NAME_LEN]; // JMC cppcheck - snprintf out of bounds    char t3[MAX_NAME_LEN]; // JMC cppcheck - snprintf out of bounds    char logicalEndName[MAX_NAME_LEN];    char logicalParentDirName[MAX_NAME_LEN];    int status;    splitPathByKey( objName, logicalParentDirName, MAX_NAME_LEN, logicalEndName, MAX_NAME_LEN, '/' );    snprintf( t1, MAX_NAME_LEN, " = '%s'", logicalEndName );    snprintf( t11, MAX_NAME_LEN, " = '%s'", logicalParentDirName );    snprintf( t2, MAX_NAME_LEN, " = '%i'", userId );    snprintf( t3, MAX_NAME_LEN, " >= '%i' ", operId );    memset( &genQueryInp, 0, sizeof( genQueryInp_t ) );    addInxIval( &genQueryInp.selectInp, COL_D_DATA_ID, 1 );    addInxVal( &genQueryInp.sqlCondInp, COL_DATA_NAME, t1 );    addInxVal( &genQueryInp.sqlCondInp, COL_COLL_NAME, t11 );    addInxVal( &genQueryInp.sqlCondInp, COL_DATA_ACCESS_USER_ID, t2 );    addInxVal( &genQueryInp.sqlCondInp, COL_DATA_ACCESS_TYPE, t3 );    genQueryInp.maxRows = 2;    status = rsGenQuery( rsComm, &genQueryInp, &genQueryOut );    freeGenQueryOut( &genQueryOut );    clearGenQueryInp( &genQueryInp );    if ( status >= 0 ) {        return 1;    }    else {        return 0;    }}

/** * /fn msiExecGenQuery(msParam_t* genQueryInParam, msParam_t* genQueryOutParam, ruleExecInfo_t *rei) * * /brief   This function executes a given general query structure and returns results * * /module core * * /since pre-2.1 * * /author  Arcot Rajasekar * /date    2008 * * /note Takes a SQL-like iRODS query (no FROM clause) and returns a table structure. Use #msiGetMoreRows to get all rows. * * /usage See clients/icommands/test/rules3.0/ * * /param[in] genQueryInParam - a msParam of type GenQueryInp_MS_T * /param[out] genQueryOutParam - a msParam of type GenQueryOut_MS_T * /param[in,out] rei - The RuleExecInfo structure that is automatically *    handled by the rule engine. The user does not include rei as a *    parameter in the rule invocation. * * /DolVarDependence none * /DolVarModified none * /iCatAttrDependence none * /iCatAttrModified none * /sideeffect none * * /return integer * /retval 0 on success * /pre none * /post none * /sa msiGetMoreRows and msiExecStrCondQuery**/int msiExecGenQuery( msParam_t* genQueryInParam, msParam_t* genQueryOutParam, ruleExecInfo_t *rei ) {    genQueryInp_t *genQueryInp;    int i;    genQueryOut_t *genQueryOut = NULL;    genQueryInp = ( genQueryInp_t* )genQueryInParam->inOutStruct;    i = rsGenQuery( rei->rsComm, genQueryInp, &genQueryOut );    if ( i < 0 ) {        if ( i == CAT_NO_ROWS_FOUND ) {            genQueryOutParam->type = strdup( GenQueryOut_MS_T );            genQueryOut = ( genQueryOut_t * ) malloc( sizeof( genQueryOut_t ) );            memset( genQueryOut, 0, sizeof( genQueryOut_t ) );            genQueryOutParam->inOutStruct = genQueryOut;            return( 0 );        }        else {            return( i );        }    }    genQueryOutParam->type = strdup( GenQueryOut_MS_T );    genQueryOutParam->inOutStruct = genQueryOut;    return( 0 );}

intgetReInfoById( rsComm_t *rsComm, char *ruleExecId, genQueryOut_t **genQueryOut ) {    genQueryInp_t genQueryInp;    char tmpStr[NAME_LEN];    int status;    memset( &genQueryInp, 0, sizeof( genQueryInp_t ) );    addInxIval( &genQueryInp.selectInp, COL_RULE_EXEC_ID, 1 );    addInxIval( &genQueryInp.selectInp, COL_RULE_EXEC_NAME, 1 );    addInxIval( &genQueryInp.selectInp, COL_RULE_EXEC_REI_FILE_PATH, 1 );    addInxIval( &genQueryInp.selectInp, COL_RULE_EXEC_USER_NAME, 1 );    addInxIval( &genQueryInp.selectInp, COL_RULE_EXEC_ADDRESS, 1 );    addInxIval( &genQueryInp.selectInp, COL_RULE_EXEC_TIME, 1 );    addInxIval( &genQueryInp.selectInp, COL_RULE_EXEC_FREQUENCY, 1 );    addInxIval( &genQueryInp.selectInp, COL_RULE_EXEC_PRIORITY, 1 );    addInxIval( &genQueryInp.selectInp, COL_RULE_EXEC_ESTIMATED_EXE_TIME, 1 );    addInxIval( &genQueryInp.selectInp, COL_RULE_EXEC_NOTIFICATION_ADDR, 1 );    addInxIval( &genQueryInp.selectInp, COL_RULE_EXEC_LAST_EXE_TIME, 1 );    addInxIval( &genQueryInp.selectInp, COL_RULE_EXEC_STATUS, 1 );    snprintf( tmpStr, NAME_LEN, "='%s'", ruleExecId );    addInxVal( &genQueryInp.sqlCondInp, COL_RULE_EXEC_ID, tmpStr );    genQueryInp.maxRows = MAX_SQL_ROWS;    status =  rsGenQuery( rsComm, &genQueryInp, genQueryOut );    clearGenQueryInp( &genQueryInp );    return status;}

intgetQuotaByResc( rsComm_t *rsComm, char *userName, char *rescName,                genQueryOut_t **genQueryOut ) {    int status;    genQueryInp_t genQueryInp;    char condition1[MAX_NAME_LEN];    char condition2[MAX_NAME_LEN];    if ( genQueryOut == NULL ) {        return USER__NULL_INPUT_ERR;    }    *genQueryOut = NULL;    memset( &genQueryInp, 0, sizeof( genQueryInp ) );    genQueryInp.options = QUOTA_QUERY;    snprintf( condition1, MAX_NAME_LEN, "%s",              userName );    addInxVal( &genQueryInp.sqlCondInp, COL_USER_NAME, condition1 );    if ( rescName != NULL && strlen( rescName ) > 0 ) {        snprintf( condition2, MAX_NAME_LEN, "%s",                  rescName );        addInxVal( &genQueryInp.sqlCondInp, COL_R_RESC_NAME, condition2 );    }    genQueryInp.maxRows = MAX_SQL_ROWS;    status = rsGenQuery( rsComm, &genQueryInp, genQueryOut );    clearGenQueryInp( &genQueryInp );    return status;}

intgetTokenId(rsComm_t *rsComm, char *tokenNameSpace, char *tokenName){  genQueryInp_t genQueryInp;  genQueryOut_t *genQueryOut = NULL;  char tmpStr[MAX_NAME_LEN];  char tmpStr2[MAX_NAME_LEN];  int status;    memset (&genQueryInp, 0, sizeof (genQueryInp_t));  snprintf (tmpStr, NAME_LEN, "='%s'", tokenNameSpace);  snprintf (tmpStr2, NAME_LEN, "='%s'", tokenName);  addInxVal (&genQueryInp.sqlCondInp, COL_TOKEN_NAMESPACE, tmpStr);  addInxVal (&genQueryInp.sqlCondInp, COL_TOKEN_NAME, tmpStr2);  addInxIval (&genQueryInp.selectInp, COL_TOKEN_ID, 1);  genQueryInp.maxRows = 2;  status =  rsGenQuery (rsComm, &genQueryInp, &genQueryOut);  clearGenQueryInp (&genQueryInp);  if (status >= 0) {    sqlResult_t *tokenIdRes;    if ((tokenIdRes = getSqlResultByInx (genQueryOut, COL_TOKEN_ID)) ==	NULL) {      rodsLog (LOG_ERROR,	       "getTokenId: getSqlResultByInx for COL_TOKEN_ID failed");      freeGenQueryOut (&genQueryOut);      return (UNMATCHED_KEY_OR_INDEX);    }    status = atoi(tokenIdRes->value);    freeGenQueryOut (&genQueryOut);  }  return(status);}

int readICatUserInfo( char *userName, char *attr, char userInfo[MAX_NAME_LEN], rsComm_t *rsComm ) {    int status;    genQueryInp_t genQueryInp;    genQueryOut_t *genQueryOut = NULL;    char condstr[MAX_NAME_LEN];    memset( &genQueryInp, 0, sizeof( genQueryInp ) );    genQueryInp.maxRows = MAX_SQL_ROWS;    snprintf( condstr, MAX_NAME_LEN, "= '%s'", userName );    addInxVal( &genQueryInp.sqlCondInp, COL_USER_NAME, condstr );    snprintf( condstr, MAX_NAME_LEN, "= '%s'", attr );    addInxVal( &genQueryInp.sqlCondInp, COL_META_USER_ATTR_NAME, condstr );    addInxIval( &genQueryInp.selectInp, COL_META_USER_ATTR_VALUE, 1 );    status = rsGenQuery( rsComm, &genQueryInp, &genQueryOut );    userInfo[0] = '/0';    if ( status >= 0 && genQueryOut->rowCnt > 0 ) {        if ( sqlResult_t *r = getSqlResultByInx( genQueryOut, COL_META_USER_ATTR_VALUE ) ) {            rstrcpy( userInfo, &r->value[0], MAX_NAME_LEN );        }        genQueryInp.continueInx =  genQueryOut->continueInx;    }    clearGenQueryInp( &genQueryInp );    freeGenQueryOut( &genQueryOut );    return status;}

intgetUserId( rsComm_t *rsComm, char *userName, char *zoneName ) {    genQueryInp_t genQueryInp;    genQueryOut_t *genQueryOut = NULL;    char tmpStr[MAX_NAME_LEN];    char tmpStr2[MAX_NAME_LEN];    int status;    memset( &genQueryInp, 0, sizeof( genQueryInp_t ) );    snprintf( tmpStr, NAME_LEN, "='%s'", userName );    snprintf( tmpStr2, NAME_LEN, "='%s'", zoneName );    addInxVal( &genQueryInp.sqlCondInp, COL_USER_NAME, tmpStr );    addInxVal( &genQueryInp.sqlCondInp, COL_USER_ZONE, tmpStr2 );    addInxIval( &genQueryInp.selectInp, COL_USER_ID, 1 );    genQueryInp.maxRows = 2;    status =  rsGenQuery( rsComm, &genQueryInp, &genQueryOut );    clearGenQueryInp( &genQueryInp );    if ( status >= 0 ) {        sqlResult_t *userIdRes;        if ( ( userIdRes = getSqlResultByInx( genQueryOut, COL_USER_ID ) ) ==                NULL ) {            rodsLog( LOG_ERROR,                     "getUserId: getSqlResultByInx for COL_USER_ID failed" );            freeGenQueryOut( &genQueryOut );            return UNMATCHED_KEY_OR_INDEX;        }        status = atoi( userIdRes->value );        freeGenQueryOut( &genQueryOut );    }    return status;}

intcheckPermitForResource( rsComm_t *rsComm, char *objName, int userId, int operId ) {    genQueryInp_t genQueryInp;    genQueryOut_t *genQueryOut = NULL;    char t1[MAX_NAME_LEN]; // JMC cppcheck - snprintf out of bounds    char t2[MAX_NAME_LEN]; // JMC cppcheck - snprintf out of bounds    char t4[MAX_NAME_LEN]; // JMC cppcheck - snprintf out of bounds    int status;    snprintf( t1, MAX_NAME_LEN, " = '%s'", objName );    snprintf( t2, MAX_NAME_LEN, " = '%i'", userId );    snprintf( t4, MAX_NAME_LEN, " >= '%i' ", operId );    memset( &genQueryInp, 0, sizeof( genQueryInp_t ) );    addInxIval( &genQueryInp.selectInp, COL_R_RESC_ID, 1 );    addInxVal( &genQueryInp.sqlCondInp, COL_R_RESC_NAME, t1 );    addInxVal( &genQueryInp.sqlCondInp, COL_RESC_ACCESS_USER_ID, t2 );    addInxVal( &genQueryInp.sqlCondInp, COL_RESC_ACCESS_TYPE, t4 );    genQueryInp.maxRows = 2;    status =  rsGenQuery( rsComm, &genQueryInp, &genQueryOut );    clearGenQueryInp( &genQueryInp );    if ( status >= 0 ) {        freeGenQueryOut( &genQueryOut );        return 1;    }    else {        return 0;    }}

static int get_resource_path( rsComm_t *conn, char *rescName, char *rescPath ) {    genQueryInp_t genQueryInp;    int i1a[10];    int i1b[10];    int i2a[10];    char *condVal[2];    char v1[200];    genQueryOut_t *genQueryOut = NULL;    sqlResult_t *vaultPathSTruct;    char *vaultPath;    int t;    memset( &genQueryInp, 0, sizeof( genQueryInp_t ) );    i1a[0] = COL_R_VAULT_PATH;    i1b[0] = 0;    genQueryInp.selectInp.inx = i1a;    genQueryInp.selectInp.value = i1b;    genQueryInp.selectInp.len = 1;    i2a[0] = COL_R_RESC_NAME;    genQueryInp.sqlCondInp.inx = i2a;    sprintf( v1, "='%s'", rescName );    condVal[0] = v1;    genQueryInp.sqlCondInp.value = condVal;    genQueryInp.sqlCondInp.len = 1;    genQueryInp.maxRows = 2;    genQueryInp.continueInx = 0;    t = rsGenQuery( conn, &genQueryInp, &genQueryOut );    if ( NULL == genQueryOut ) { // JMC cppecheck - nullptr        rodsLog( LOG_ERROR, "get_resource_path :: genQueryOut is NULL" );        return 0;    }    if ( t < 0 ) {        if ( t == CAT_NO_ROWS_FOUND ) { /* no data is found */            return 0;        }        return( t );    }    if ( genQueryOut->rowCnt < 0 ) {        return -1;    }    vaultPathSTruct = getSqlResultByInx( genQueryOut, COL_R_VAULT_PATH );    vaultPath = &vaultPathSTruct->value[0];    strcpy( rescPath, vaultPath );    freeGenQueryOut( &genQueryOut );    return 0;}

// =-=-=-=-=-=-=-// JMC - backport 4552intgetNumSubfilesInBunfileObj( rsComm_t *rsComm, char *objPath ) {    int status;    genQueryOut_t *genQueryOut = NULL;    genQueryInp_t genQueryInp;    int totalRowCount;    char condStr[MAX_NAME_LEN];    bzero( &genQueryInp, sizeof( genQueryInp ) );    genQueryInp.maxRows = 1;    genQueryInp.options = RETURN_TOTAL_ROW_COUNT;    snprintf( condStr, MAX_NAME_LEN, "='%s'", objPath );    addInxVal( &genQueryInp.sqlCondInp, COL_D_DATA_PATH, condStr );    snprintf( condStr, MAX_NAME_LEN, "='%s'", BUNDLE_RESC_CLASS );    addInxVal( &genQueryInp.sqlCondInp, COL_R_CLASS_NAME, condStr );    addKeyVal( &genQueryInp.condInput, ZONE_KW, objPath );    addInxIval( &genQueryInp.selectInp, COL_COLL_NAME, 1 );    addInxIval( &genQueryInp.selectInp, COL_DATA_NAME, 1 );    addInxIval( &genQueryInp.selectInp, COL_DATA_SIZE, 1 );    status = rsGenQuery( rsComm, &genQueryInp, &genQueryOut );    if ( genQueryOut == NULL || status < 0 ) {        freeGenQueryOut( &genQueryOut );        clearGenQueryInp( &genQueryInp );        if ( status == CAT_NO_ROWS_FOUND ) {            return 0;        }        else {            return status;        }    }    totalRowCount = genQueryOut->totalRowCount;    freeGenQueryOut( &genQueryOut );    /* clear result */    genQueryInp.maxRows = 0;    rsGenQuery( rsComm, &genQueryInp, &genQueryOut );    clearGenQueryInp( &genQueryInp );    return totalRowCount;}

/* checkDupReplica - Check if a given object with a given rescName * and physical path already exist. If it does, returns the replNum. * JMC - backport 4497 */intcheckDupReplica( rsComm_t *rsComm, rodsLong_t dataId, char *rescName,                 char *filePath ) {    genQueryInp_t genQueryInp;    genQueryOut_t *genQueryOut = NULL;    char tmpStr[MAX_NAME_LEN];    int status;    if ( rsComm == NULL || rescName == NULL || filePath == NULL ) {        return USER__NULL_INPUT_ERR;    }    bzero( &genQueryInp, sizeof( genQueryInp_t ) );    rodsLong_t resc_id;    irods::error ret = resc_mgr.hier_to_leaf_id(rescName,resc_id);    if(!ret.ok()) {        irods::log(PASS(ret));        return ret.code();    }    std::string resc_id_str = boost::lexical_cast<std::string>(resc_id);    snprintf( tmpStr, MAX_NAME_LEN, "='%s'", resc_id_str.c_str() );    addInxVal( &genQueryInp.sqlCondInp, COL_D_RESC_ID, tmpStr );    snprintf( tmpStr, MAX_NAME_LEN, "='%s'", filePath );    addInxVal( &genQueryInp.sqlCondInp, COL_D_DATA_PATH, tmpStr );    snprintf( tmpStr, MAX_NAME_LEN, "='%lld'", dataId );    addInxVal( &genQueryInp.sqlCondInp, COL_D_DATA_ID, tmpStr );    addInxIval( &genQueryInp.selectInp, COL_DATA_REPL_NUM, 1 );    genQueryInp.maxRows = 2;    status = rsGenQuery( rsComm, &genQueryInp, &genQueryOut );    clearGenQueryInp( &genQueryInp );    if ( status >= 0 ) {        int intReplNum;        sqlResult_t *replNum;        if ( ( replNum = getSqlResultByInx( genQueryOut, COL_DATA_REPL_NUM ) ) ==                NULL ) {            freeGenQueryOut( &genQueryOut );            rodsLog( LOG_ERROR,                     "checkDupReplica: getSqlResultByInx COL_DATA_REPL_NUM failed" );            return UNMATCHED_KEY_OR_INDEX;        }        intReplNum = atoi( replNum->value );        freeGenQueryOut( &genQueryOut );        return intReplNum;    }    else {        freeGenQueryOut( &genQueryOut );        return status;    }}

/** * /fn msiExecStrCondQuery(msParam_t* queryParam, msParam_t* genQueryOutParam, ruleExecInfo_t *rei) * * /brief   This function takes a given condition string, creates an iCAT query, executes it and returns the values * * /module core * * /since pre-2.1 * * * /usage See clients/icommands/test/rules3.0/ * * /param[in] queryParam - a msParam of type GenQueryInp_MS_T * /param[out] genQueryOutParam - a msParam of type GenQueryOut_MS_T * /param[in,out] rei - The RuleExecInfo structure that is automatically *    handled by the rule engine. The user does not include rei as a *    parameter in the rule invocation. * * /DolVarDependence none * /DolVarModified none * /iCatAttrDependence none * /iCatAttrModified none * /sideeffect none * * /return integer * /retval 0 on success * /pre none * /post none * /sa none**/int msiExecStrCondQuery( msParam_t* queryParam, msParam_t* genQueryOutParam, ruleExecInfo_t *rei ) {    genQueryInp_t genQueryInp;    int i;    genQueryOut_t *genQueryOut = NULL;    char *query;    query = ( char * ) malloc( strlen( ( const char* )queryParam->inOutStruct ) + 10 + MAX_COND_LEN * 8 );    strcpy( query, ( const char* )queryParam->inOutStruct );    /**** Jun 27, 2007    if (queryParam->inOutStruct == NULL) {      query = (char *) malloc(strlen(queryParam->label) + MAX_COND_LEN);      strcpy(query , queryParam->label);    }    else {      query = (char *) malloc(strlen(queryParam->inOutStruct) + MAX_COND_LEN);      strcpy(query , queryParam->inOutStruct);    }    i  = replaceVariablesAndMsParams("",query, rei->msParamArray, rei);    if (i < 0)      return i;    ***/    memset( &genQueryInp, 0, sizeof( genQueryInp_t ) );    i = fillGenQueryInpFromStrCond( query, &genQueryInp );    free( query );    if ( i < 0 ) {        return i;    }    genQueryInp.maxRows = MAX_SQL_ROWS;    genQueryInp.continueInx = 0;    i = rsGenQuery( rei->rsComm, &genQueryInp, &genQueryOut );    if ( i < 0 ) {        if ( i == CAT_NO_ROWS_FOUND ) {            genQueryOutParam->type = strdup( GenQueryOut_MS_T );            genQueryOut = ( genQueryOut_t * ) malloc( sizeof( genQueryOut_t ) );            memset( genQueryOut, 0, sizeof( genQueryOut_t ) );            genQueryOutParam->inOutStruct = genQueryOut;            return 0;        }        else {            return i;        }    }    genQueryOutParam->type = strdup( GenQueryOut_MS_T );    genQueryOutParam->inOutStruct = genQueryOut;    return 0;}

intisData(rsComm_t *rsComm, char *objName, rodsLong_t *dataId) {    char logicalEndName[MAX_NAME_LEN]{};    char logicalParentDirName[MAX_NAME_LEN]{};    auto status{splitPathByKey(objName, logicalParentDirName, MAX_NAME_LEN, logicalEndName, MAX_NAME_LEN, '/')};    if (status < 0) {        const auto err{ERROR(status,                             (boost::format("splitPathByKey failed for [%s]") %                              objName).str().c_str())};        irods::log(err);        return err.code();    }    genQueryInp_t genQueryInp{};    genQueryOut_t *genQueryOut{};    char tmpStr[MAX_NAME_LEN]{};    memset(&genQueryInp, 0, sizeof(genQueryInp_t));    snprintf(tmpStr, MAX_NAME_LEN, "='%s'", logicalEndName);    addInxVal(&genQueryInp.sqlCondInp, COL_DATA_NAME, tmpStr);    addInxIval(&genQueryInp.selectInp, COL_D_DATA_ID, 1);    snprintf(tmpStr, MAX_NAME_LEN, "='%s'", logicalParentDirName);    addInxVal(&genQueryInp.sqlCondInp, COL_COLL_NAME, tmpStr);    addInxIval(&genQueryInp.selectInp, COL_COLL_ID, 1);    genQueryInp.maxRows = 2;    status = rsGenQuery(rsComm, &genQueryInp, &genQueryOut);    if (status < 0) {        freeGenQueryOut(&genQueryOut);        clearGenQueryInp(&genQueryInp);        return status;    }    sqlResult_t *dataIdRes{getSqlResultByInx(genQueryOut, COL_D_DATA_ID)};    if (NULL == dataIdRes) {        const auto err{ERROR(UNMATCHED_KEY_OR_INDEX, "getSqlResultByInx for COL_D_DATA_ID failed")};        irods::log(err);        return err.code();    }    if (NULL != dataId) {        *dataId = strtoll(dataIdRes->value, 0, 0);    }    freeGenQueryOut(&genQueryOut);    clearGenQueryInp(&genQueryInp);    return status;}

/** * /fn msiCheckHostAccessControl (ruleExecInfo_t *rei) * * /brief  This microservice sets the access control policy. It checks the *  access control by host and user based on the the policy given in the *  HostAccessControl file. * * /module core * * /since pre-2.1 * * /author Jean-Yves Nief * /date 2007-09 * * /note  This microservice controls access to the iRODS service *  based on the information in the host based access configuration file: *  HOST_ACCESS_CONTROL_FILE * * /usage See clients/icommands/test/rules3.0/ * * /param[in,out] rei - The RuleExecInfo structure that is automatically *    handled by the rule engine. The user does not include rei as a *    parameter in the rule invocation. * * /DolVarDependence none * /DolVarModified none * /iCatAttrDependence none * /iCatAttrModified none * /sideeffect none * * /return integer * /retval 0 upon success * /pre N/A * /post N/A * /sa N/A **/int msiCheckHostAccessControl( ruleExecInfo_t *rei ) {    char group[MAX_NAME_LEN], *hostclient, *result, *username;    char condstr[MAX_NAME_LEN];    int i, rc, status;    genQueryInp_t genQueryInp;    genQueryOut_t *genQueryOut = NULL;    rsComm_t *rsComm;    RE_TEST_MACRO( "    Calling msiCheckHostAccessControl" )    /* the above line is needed for loop back testing using irule -i option */    group[0] = '/0';    rsComm = rei->rsComm;    /* retrieve user name */    username = rsComm->clientUser.userName;    /* retrieve client IP address */    hostclient = inet_ntoa( rsComm->remoteAddr.sin_addr );    /* retrieve groups to which the user belong */    memset( &genQueryInp, 0, sizeof( genQueryInp ) );    snprintf( condstr, MAX_NAME_LEN, "= '%s'", username );    addInxVal( &genQueryInp.sqlCondInp, COL_USER_NAME, condstr );    addInxIval( &genQueryInp.selectInp, COL_USER_GROUP_NAME, 1 );    genQueryInp.maxRows = MAX_SQL_ROWS;    status =  rsGenQuery( rsComm, &genQueryInp, &genQueryOut );    if ( status >= 0 ) {        for ( i = 0; i < genQueryOut->rowCnt; i++ ) {            result = genQueryOut->sqlResult[0].value;            result += i * genQueryOut->sqlResult[0].len;            strcat( group, result );            strcat( group, " " );        }    }    else {        rstrcpy( group, "all", MAX_NAME_LEN );    }    clearGenQueryInp( &genQueryInp );    freeGenQueryOut( &genQueryOut );    rc = checkHostAccessControl( username, hostclient, group );    if ( rc < 0 ) {        rodsLog( LOG_NOTICE, "Access to user %s from host %s has been refused./n", username, hostclient );        rei->status = rc;    }    return rei->status;}

intisResc( rsComm_t *rsComm, char *objName ) {    genQueryInp_t genQueryInp;    genQueryOut_t *genQueryOut = NULL;    char tmpStr[NAME_LEN];    int status;    memset( &genQueryInp, 0, sizeof( genQueryInp_t ) );    snprintf( tmpStr, NAME_LEN, "='%s'", objName );    addInxVal( &genQueryInp.sqlCondInp, COL_R_RESC_NAME, tmpStr );    addInxIval( &genQueryInp.selectInp, COL_R_RESC_ID, 1 );    genQueryInp.maxRows = 2;    status =  rsGenQuery( rsComm, &genQueryInp, &genQueryOut );    freeGenQueryOut( &genQueryOut );    clearGenQueryInp( &genQueryInp );    return status;}

/* querySpecColl - The query can produce multiple answer and only one * is correct. e.g., objPath = /x/yabc can produce answers: * /x/y, /x/ya, /x/yabc, etc. The calling subroutine need to screen * /x/y, /x/ya out * check queueSpecCollCache () for screening. */intquerySpecColl( rsComm_t *rsComm, char *objPath, genQueryOut_t **genQueryOut ) {    genQueryInp_t genQueryInp;    int status;    char condStr[MAX_NAME_LEN];    if ( HaveFailedSpecCollPath && strcmp( objPath, FailedSpecCollPath ) == 0 ) {        return CAT_NO_ROWS_FOUND;    }    /* see if objPath is in the path of a spec collection */    memset( &genQueryInp, 0, sizeof( genQueryInp ) );    snprintf( condStr, MAX_NAME_LEN, "parent_of '%s'", objPath );    addInxVal( &genQueryInp.sqlCondInp, COL_COLL_NAME, condStr );    rstrcpy( condStr, "like '_%'", MAX_NAME_LEN );    addInxVal( &genQueryInp.sqlCondInp, COL_COLL_TYPE, condStr );    addInxIval( &genQueryInp.selectInp, COL_COLL_ID, 1 );    addInxIval( &genQueryInp.selectInp, COL_COLL_NAME, 1 );    addInxIval( &genQueryInp.selectInp, COL_COLL_OWNER_NAME, 1 );    addInxIval( &genQueryInp.selectInp, COL_COLL_OWNER_ZONE, 1 );    addInxIval( &genQueryInp.selectInp, COL_COLL_CREATE_TIME, 1 );    addInxIval( &genQueryInp.selectInp, COL_COLL_MODIFY_TIME, 1 );    addInxIval( &genQueryInp.selectInp, COL_COLL_TYPE, 1 );    addInxIval( &genQueryInp.selectInp, COL_COLL_INFO1, 1 );    addInxIval( &genQueryInp.selectInp, COL_COLL_INFO2, 1 );    genQueryInp.maxRows = MAX_SQL_ROWS;    status =  rsGenQuery( rsComm, &genQueryInp, genQueryOut );    clearGenQueryInp( &genQueryInp );    if ( status < 0 ) {        rstrcpy( FailedSpecCollPath, objPath, MAX_NAME_LEN );        HaveFailedSpecCollPath = 1;        return status;    }    return 0;}

/* checkDupReplica - Check if a given object with a given rescName * and physical path already exist. If it does, returns the replNum. * JMC - backport 4497 */intcheckDupReplica( rsComm_t *rsComm, rodsLong_t dataId, char *rescName,                 char *filePath ) {    genQueryInp_t genQueryInp;    genQueryOut_t *genQueryOut = NULL;    char tmpStr[MAX_NAME_LEN];    int status;    if ( rsComm == NULL || rescName == NULL || filePath == NULL ) {        return USER__NULL_INPUT_ERR;    }    bzero( &genQueryInp, sizeof( genQueryInp_t ) );    snprintf( tmpStr, MAX_NAME_LEN, "='%s'", rescName );    addInxVal( &genQueryInp.sqlCondInp, COL_D_RESC_NAME, tmpStr );    snprintf( tmpStr, MAX_NAME_LEN, "='%s'", filePath );    addInxVal( &genQueryInp.sqlCondInp, COL_D_DATA_PATH, tmpStr );    snprintf( tmpStr, MAX_NAME_LEN, "='%lld'", dataId );    addInxVal( &genQueryInp.sqlCondInp, COL_D_DATA_ID, tmpStr );    addInxIval( &genQueryInp.selectInp, COL_DATA_REPL_NUM, 1 );    genQueryInp.maxRows = 2;    status =  rsGenQuery( rsComm, &genQueryInp, &genQueryOut );    clearGenQueryInp( &genQueryInp );    if ( status >= 0 ) {        int intReplNum;        sqlResult_t *replNum;        if ( ( replNum = getSqlResultByInx( genQueryOut, COL_DATA_REPL_NUM ) ) ==                NULL ) {            rodsLog( LOG_ERROR,                     "checkDupReplica: getSqlResultByInx COL_DATA_REPL_NUM failed" );            return UNMATCHED_KEY_OR_INDEX;        }        intReplNum = atoi( replNum->value );        freeGenQueryOut( &genQueryOut );        return intReplNum;    }    else {        return status;    }}

intsvrCloseQueryOut( rsComm_t *rsComm, genQueryOut_t *genQueryOut ) {    genQueryInp_t genQueryInp;    genQueryOut_t *junk = NULL;    int status;    if ( genQueryOut->continueInx <= 0 ) {        return 0;    }    memset( &genQueryInp, 0, sizeof( genQueryInp_t ) );    /* maxRows = 0 specifies that the genQueryOut should be closed */    genQueryInp.maxRows = 0;;    genQueryInp.continueInx = genQueryOut->continueInx;    status =  rsGenQuery( rsComm, &genQueryInp, &junk );    return status;}

intcheckCollAccessPerm( rsComm_t *rsComm, char *collection, char *accessPerm ) {    char accStr[LONG_NAME_LEN];    char condStr[MAX_NAME_LEN];    genQueryInp_t genQueryInp;    genQueryOut_t *genQueryOut = NULL;    int status;    if ( collection == NULL || accessPerm == NULL ) {        return SYS_INTERNAL_NULL_INPUT_ERR;    }    memset( &genQueryInp, 0, sizeof( genQueryInp ) );    snprintf( accStr, LONG_NAME_LEN, "%s", rsComm->clientUser.userName );    addKeyVal( &genQueryInp.condInput, USER_NAME_CLIENT_KW, accStr );    snprintf( accStr, LONG_NAME_LEN, "%s", rsComm->clientUser.rodsZone );    addKeyVal( &genQueryInp.condInput, RODS_ZONE_CLIENT_KW, accStr );    snprintf( accStr, LONG_NAME_LEN, "%s", accessPerm );    addKeyVal( &genQueryInp.condInput, ACCESS_PERMISSION_KW, accStr );    snprintf( condStr, MAX_NAME_LEN, "='%s'", collection );    addInxVal( &genQueryInp.sqlCondInp, COL_COLL_NAME, condStr );    addInxIval( &genQueryInp.selectInp, COL_COLL_ID, 1 );    genQueryInp.maxRows = MAX_SQL_ROWS;    status =  rsGenQuery( rsComm, &genQueryInp, &genQueryOut );    clearGenQueryInp( &genQueryInp );    if ( status >= 0 ) {        freeGenQueryOut( &genQueryOut );    }    return status;}

intisData (rsComm_t *rsComm, char *objName, rodsLong_t *dataId){    genQueryInp_t genQueryInp;    genQueryOut_t *genQueryOut = NULL;    char tmpStr[MAX_NAME_LEN];    char logicalEndName[MAX_NAME_LEN];    char logicalParentDirName[MAX_NAME_LEN];    int status;    status = splitPathByKey(objName,			    logicalParentDirName, logicalEndName, '/');    memset (&genQueryInp, 0, sizeof (genQueryInp_t));    snprintf (tmpStr, MAX_NAME_LEN, "='%s'", logicalEndName);    addInxVal (&genQueryInp.sqlCondInp, COL_DATA_NAME, tmpStr);    addInxIval (&genQueryInp.selectInp, COL_D_DATA_ID, 1);    snprintf (tmpStr, MAX_NAME_LEN, "='%s'", logicalParentDirName);    addInxVal (&genQueryInp.sqlCondInp, COL_COLL_NAME, tmpStr);    addInxIval (&genQueryInp.selectInp, COL_COLL_ID, 1);    genQueryInp.maxRows = 2;    status =  rsGenQuery (rsComm, &genQueryInp, &genQueryOut);    if (status >= 0) {        sqlResult_t *dataIdRes;        if ((dataIdRes = getSqlResultByInx (genQueryOut, COL_D_DATA_ID)) ==          NULL) {            rodsLog (LOG_ERROR,              "isData: getSqlResultByInx for COL_D_DATA_ID failed");            return (UNMATCHED_KEY_OR_INDEX);        }	if (dataId != NULL) {            *dataId = strtoll (dataIdRes->value, 0, 0);	}	freeGenQueryOut (&genQueryOut);    }    clearGenQueryInp (&genQueryInp);    return(status);}

intrsQueryCollInColl( rsComm_t *rsComm, char *collection,                   genQueryInp_t *genQueryInp, genQueryOut_t **genQueryOut ) {    char collQCond[MAX_NAME_LEN];    int status;    if ( collection == NULL || genQueryOut == NULL ) {        return USER__NULL_INPUT_ERR;    }    memset( genQueryInp, 0, sizeof( genQueryInp_t ) );    snprintf( collQCond, MAX_NAME_LEN, "='%s'", collection );    addInxVal( &genQueryInp->sqlCondInp, COL_COLL_PARENT_NAME, collQCond );    addInxIval( &genQueryInp->selectInp, COL_COLL_NAME, 1 );    genQueryInp->maxRows = MAX_SQL_ROWS;    status =  rsGenQuery( rsComm, genQueryInp, genQueryOut );    return status;}

intgetPhyPath (rsComm_t *rsComm, char *objName,  char *resource, char *phyPath){   genQueryInp_t genQueryInp;    genQueryOut_t *genQueryOut = NULL;    char tmpStr[MAX_NAME_LEN];    char logicalEndName[MAX_NAME_LEN];    char logicalParentDirName[MAX_NAME_LEN];    int status;    status = splitPathByKey(objName,                            logicalParentDirName, logicalEndName, '/');    memset (&genQueryInp, 0, sizeof (genQueryInp_t));    snprintf (tmpStr, MAX_NAME_LEN, "='%s'", logicalEndName);    addInxVal (&genQueryInp.sqlCondInp, COL_DATA_NAME, tmpStr);    snprintf (tmpStr, MAX_NAME_LEN, "='%s'", logicalParentDirName);    addInxVal (&genQueryInp.sqlCondInp, COL_COLL_NAME, tmpStr);    addInxIval (&genQueryInp.selectInp, COL_D_DATA_PATH, 1);    genQueryInp.maxRows = 2;    status =  rsGenQuery (rsComm, &genQueryInp, &genQueryOut);    if (status >= 0) {        sqlResult_t *phyPathRes = NULL;        if ((phyPathRes = getSqlResultByInx (genQueryOut, COL_D_DATA_PATH)) ==          NULL) {            rodsLog (LOG_ERROR,              "getPhyPath: getSqlResultByInx for COL_D_DATA_PATH failed");            return (UNMATCHED_KEY_OR_INDEX);        }        if (phyPath != NULL) {            rstrcpy (phyPath, phyPathRes->value, MAX_NAME_LEN);        }        freeGenQueryOut (&genQueryOut);    }    clearGenQueryInp (&genQueryInp);    return(status);}

/** * /fn msiExecGenQuery(msParam_t* genQueryInParam, msParam_t* genQueryOutParam, ruleExecInfo_t *rei) * * /brief   This function executes a given general query structure and returns results * * /module core * * /since pre-2.1 * * * /note Takes a SQL-like iRODS query (no FROM clause) and returns a table structure. Use #msiGetMoreRows to get all rows. * * /usage See clients/icommands/test/rules/ * * /param[in] genQueryInParam - a msParam of type GenQueryInp_MS_T * /param[out] genQueryOutParam - a msParam of type GenQueryOut_MS_T * /param[in,out] rei - The RuleExecInfo structure that is automatically *    handled by the rule engine. The user does not include rei as a *    parameter in the rule invocation. * * /DolVarDependence none * /DolVarModified none * /iCatAttrDependence none * /iCatAttrModified none * /sideeffect none * * /return integer * /retval 0 on success * /pre none * /post none * /sa msiGetMoreRows and msiExecStrCondQuery**/int msiExecGenQuery( msParam_t* genQueryInParam, msParam_t* genQueryOutParam, ruleExecInfo_t *rei ) {    genQueryInp_t *genQueryInp;    int i;    genQueryOut_t *genQueryOut = NULL;    genQueryInp = ( genQueryInp_t* )genQueryInParam->inOutStruct;    i = rsGenQuery( rei->rsComm, genQueryInp, &genQueryOut );    if ( i < 0 ) {        if ( i == CAT_NO_ROWS_FOUND ) {            genQueryOutParam->type = strdup( GenQueryOut_MS_T );            genQueryOutParam->inOutStruct = genQueryOut;            return 0;        }        else {            freeGenQueryOut(&genQueryOut);            return i;        }    }    genQueryOutParam->type = strdup( GenQueryOut_MS_T );    genQueryOutParam->inOutStruct = genQueryOut;    return 0;}

/** * /fn msiExecStrCondQuery(msParam_t* queryParam, msParam_t* genQueryOutParam, ruleExecInfo_t *rei) * * /brief   This function takes a given condition string, creates an iCAT query, executes it and returns the values * * /module core * * /since pre-2.1 * * * /usage See clients/icommands/test/rules/ * * /param[in] queryParam - a msParam of type GenQueryInp_MS_T * /param[out] genQueryOutParam - a msParam of type GenQueryOut_MS_T * /param[in,out] rei - The RuleExecInfo structure that is automatically *    handled by the rule engine. The user does not include rei as a *    parameter in the rule invocation. * * /DolVarDependence none * /DolVarModified none * /iCatAttrDependence none * /iCatAttrModified none * /sideeffect none * * /return integer * /retval 0 on success * /pre none * /post none * /sa none**/int msiExecStrCondQuery( msParam_t* queryParam, msParam_t* genQueryOutParam, ruleExecInfo_t *rei ) {    genQueryInp_t genQueryInp;    int i;    genQueryOut_t *genQueryOut = NULL;    char *query;    query = ( char * ) malloc( strlen( ( const char* )queryParam->inOutStruct ) + 10 + MAX_NAME_LEN * 8 );    strcpy( query, ( const char* )queryParam->inOutStruct );    memset( &genQueryInp, 0, sizeof( genQueryInp_t ) );    i = fillGenQueryInpFromStrCond( query, &genQueryInp );    free( query );    if ( i < 0 ) {        return i;    }    genQueryInp.maxRows = MAX_SQL_ROWS;    genQueryInp.continueInx = 0;    i = rsGenQuery( rei->rsComm, &genQueryInp, &genQueryOut );    if ( i < 0 ) {        if ( i == CAT_NO_ROWS_FOUND ) {            genQueryOutParam->type = strdup( GenQueryOut_MS_T );            genQueryOut = ( genQueryOut_t * ) malloc( sizeof( genQueryOut_t ) );            memset( genQueryOut, 0, sizeof( genQueryOut_t ) );            genQueryOutParam->inOutStruct = genQueryOut;            return 0;        }        else {            return i;        }    }    genQueryOutParam->type = strdup( GenQueryOut_MS_T );    genQueryOutParam->inOutStruct = genQueryOut;    return 0;}

intcollStat( rsComm_t *rsComm, dataObjInp_t *dataObjInp,          rodsObjStat_t **rodsObjStatOut ) {    genQueryInp_t genQueryInp;    genQueryOut_t *genQueryOut = NULL;    int status;    char condStr[MAX_NAME_LEN];    sqlResult_t *dataId;    sqlResult_t *ownerName;    sqlResult_t *ownerZone;    sqlResult_t *createTime;    sqlResult_t *modifyTime;    sqlResult_t *collType;    sqlResult_t *collInfo1;    sqlResult_t *collInfo2;    /* see if objPath is a collection */    memset( &genQueryInp, 0, sizeof( genQueryInp ) );    snprintf( condStr, MAX_NAME_LEN, "='%s'", dataObjInp->objPath );    addInxVal( &genQueryInp.sqlCondInp, COL_COLL_NAME, condStr );    addInxIval( &genQueryInp.selectInp, COL_COLL_ID, 1 );    /* XXXX COL_COLL_NAME added for queueSpecColl */    addInxIval( &genQueryInp.selectInp, COL_COLL_NAME, 1 );    addInxIval( &genQueryInp.selectInp, COL_COLL_OWNER_NAME, 1 );    addInxIval( &genQueryInp.selectInp, COL_COLL_OWNER_ZONE, 1 );    addInxIval( &genQueryInp.selectInp, COL_COLL_CREATE_TIME, 1 );    addInxIval( &genQueryInp.selectInp, COL_COLL_MODIFY_TIME, 1 );    /* XXXX may want to do this if spec coll is supported */    addInxIval( &genQueryInp.selectInp, COL_COLL_TYPE, 1 );    addInxIval( &genQueryInp.selectInp, COL_COLL_INFO1, 1 );    addInxIval( &genQueryInp.selectInp, COL_COLL_INFO2, 1 );    genQueryInp.maxRows = MAX_SQL_ROWS;    status =  rsGenQuery( rsComm, &genQueryInp, &genQueryOut );    if ( status >= 0 ) {        *rodsObjStatOut = ( rodsObjStat_t * ) malloc( sizeof( rodsObjStat_t ) );        memset( *rodsObjStatOut, 0, sizeof( rodsObjStat_t ) );        ( *rodsObjStatOut )->objType = COLL_OBJ_T;        status = ( int )COLL_OBJ_T;        if ( ( dataId = getSqlResultByInx( genQueryOut,                                           COL_COLL_ID ) ) == NULL ) {            rodsLog( LOG_ERROR,                     "_rsObjStat: getSqlResultByInx for COL_COLL_ID failed" );            return UNMATCHED_KEY_OR_INDEX;        }        else if ( ( ownerName = getSqlResultByInx( genQueryOut,                                COL_COLL_OWNER_NAME ) ) == NULL ) {            rodsLog( LOG_ERROR,                     "_rsObjStat:getSqlResultByInx for COL_COLL_OWNER_NAME failed" );            return UNMATCHED_KEY_OR_INDEX;        }        else if ( ( ownerZone = getSqlResultByInx( genQueryOut,                                COL_COLL_OWNER_ZONE ) ) == NULL ) {            rodsLog( LOG_ERROR,                     "_rsObjStat:getSqlResultByInx for COL_COLL_OWNER_ZONE failed" );            return UNMATCHED_KEY_OR_INDEX;        }        else if ( ( createTime = getSqlResultByInx( genQueryOut,                                 COL_COLL_CREATE_TIME ) ) == NULL ) {            rodsLog( LOG_ERROR,                     "_rsObjStat:getSqlResultByInx for COL_COLL_CREATE_TIME failed" );            return UNMATCHED_KEY_OR_INDEX;        }        else if ( ( modifyTime = getSqlResultByInx( genQueryOut,                                 COL_COLL_MODIFY_TIME ) ) == NULL ) {            rodsLog( LOG_ERROR,                     "_rsObjStat:getSqlResultByInx for COL_COLL_MODIFY_TIME failed" );            return UNMATCHED_KEY_OR_INDEX;        }        else if ( ( collType = getSqlResultByInx( genQueryOut,                               COL_COLL_TYPE ) ) == NULL ) {            rodsLog( LOG_ERROR,                     "_rsObjStat:getSqlResultByInx for COL_COLL_TYPE failed" );            return UNMATCHED_KEY_OR_INDEX;        }        else if ( ( collInfo1 = getSqlResultByInx( genQueryOut,                                COL_COLL_INFO1 ) ) == NULL ) {            rodsLog( LOG_ERROR,                     "_rsObjStat:getSqlResultByInx for COL_COLL_INFO1 failed" );            return UNMATCHED_KEY_OR_INDEX;        }        else if ( ( collInfo2 = getSqlResultByInx( genQueryOut,                                COL_COLL_INFO2 ) ) == NULL ) {            rodsLog( LOG_ERROR,                     "_rsObjStat:getSqlResultByInx for COL_COLL_INFO2 failed" );            return UNMATCHED_KEY_OR_INDEX;        }        else {            rstrcpy( ( *rodsObjStatOut )->dataId, dataId->value, NAME_LEN );            rstrcpy( ( *rodsObjStatOut )->ownerName, ownerName->value,                     NAME_LEN );            rstrcpy( ( *rodsObjStatOut )->ownerZone, ownerZone->value,                     NAME_LEN );            rstrcpy( ( *rodsObjStatOut )->createTime, createTime->value,                     TIME_LEN );            rstrcpy( ( *rodsObjStatOut )->modifyTime, modifyTime->value,                     TIME_LEN );//.........这里部分代码省略.........

intrsQueryDataObjInCollReCur( rsComm_t *rsComm, char *collection,                           genQueryInp_t *genQueryInp, genQueryOut_t **genQueryOut, char *accessPerm,                           int singleFlag ) {    char collQCond[MAX_NAME_LEN * 2];    int status = 0;    char accStr[LONG_NAME_LEN];    if ( genQueryInp == NULL ||            collection  == NULL ||            genQueryOut == NULL ) {        return USER__NULL_INPUT_ERR;    }    memset( genQueryInp, 0, sizeof( genQueryInp_t ) );    genAllInCollQCond( collection, collQCond );    addInxVal( &genQueryInp->sqlCondInp, COL_COLL_NAME, collQCond );    addInxIval( &genQueryInp->selectInp, COL_D_DATA_ID, 1 );    addInxIval( &genQueryInp->selectInp, COL_COLL_NAME, 1 );    addInxIval( &genQueryInp->selectInp, COL_DATA_NAME, 1 );    if ( singleFlag == 0 ) {        addInxIval( &genQueryInp->selectInp, COL_DATA_REPL_NUM, 1 );        addInxIval( &genQueryInp->selectInp, COL_D_RESC_NAME, 1 );        addInxIval( &genQueryInp->selectInp, COL_D_DATA_PATH, 1 );    }    addInxIval( &genQueryInp->selectInp, COL_D_RESC_HIER, 1 );    if ( accessPerm != NULL ) {        snprintf( accStr, LONG_NAME_LEN, "%s", rsComm->clientUser.userName );        addKeyVal( &genQueryInp->condInput, USER_NAME_CLIENT_KW, accStr );        snprintf( accStr, LONG_NAME_LEN, "%s", rsComm->clientUser.rodsZone );        addKeyVal( &genQueryInp->condInput, RODS_ZONE_CLIENT_KW, accStr );        snprintf( accStr, LONG_NAME_LEN, "%s", accessPerm );        addKeyVal( &genQueryInp->condInput, ACCESS_PERMISSION_KW, accStr );        /* have to set it to 1 because it only check the first one */        genQueryInp->maxRows = 1;        status =  rsGenQuery( rsComm, genQueryInp, genQueryOut );        rmKeyVal( &genQueryInp->condInput, USER_NAME_CLIENT_KW );        rmKeyVal( &genQueryInp->condInput, RODS_ZONE_CLIENT_KW );        rmKeyVal( &genQueryInp->condInput, ACCESS_PERMISSION_KW );    }    else {        genQueryInp->maxRows = MAX_SQL_ROWS;        status = trySpecificQueryDataObjInCollReCur(                     rsComm,                     collection,                     genQueryOut );        if ( status < 0 && status != CAT_NO_ROWS_FOUND ) {            rodsLog(                LOG_NOTICE,                "Note: DataObjInCollReCur specific-Query failed (not defined?), running standard query, status=%d",                status );            /* remove the level 0 error msg added by the specific-query failure */            status = freeRErrorContent( &rsComm->rError );            /* fall back to the general-query call which used before this               specific-query was added (post 3.3.1) */            genQueryInp->maxRows = MAX_SQL_ROWS;            status =  rsGenQuery( rsComm, genQueryInp, genQueryOut );        }    }    return status;}

//.........这里部分代码省略.........    }    if ( strcmp( disk_wght->type, STR_MS_T ) == 0 ) {        weight[4] = atoi( ( const char* )disk_wght->inOutStruct );    }    else {        rodsLogAndErrorMsg( LOG_ERROR, &rsComm->rError, rei->status,                            "msiDigestMonStat: Unsupported input disk_wght type %s",                            disk_wght->type );        return rei->status;    }    if ( strcmp( netin_wght->type, STR_MS_T ) == 0 ) {        weight[5] = atoi( ( const char* )netin_wght->inOutStruct );    }    else {        rodsLogAndErrorMsg( LOG_ERROR, &rsComm->rError, rei->status,                            "msiDigestMonStat: Unsupported input netin_wght type %s",                            netin_wght->type );        return rei->status;    }    if ( strcmp( netout_wght->type, STR_MS_T ) == 0 ) {        weight[6] = atoi( ( const char* )netout_wght->inOutStruct );    }    else {        rodsLogAndErrorMsg( LOG_ERROR, &rsComm->rError, rei->status,                            "msiDigestMonStat: Unsupported input netout_wght type %s",                            netout_wght->type );        return rei->status;    }    totalWeight = 0;    for ( i = 0; i < NRESULT; i++ ) {        totalWeight += weight[i];    }    memset( &genQueryInp, 0, sizeof( genQueryInp ) );    addInxIval( &genQueryInp.selectInp, COL_SL_RESC_NAME, 1 );    addInxIval( &genQueryInp.selectInp, COL_SL_CREATE_TIME, SELECT_MAX );    genQueryInp.maxRows = MAX_SQL_ROWS;    status =  rsGenQuery( rsComm, &genQueryInp, &genQueryOut );    if ( NULL == genQueryOut ) { // JMC cppcheck - nullptr        rodsLog( LOG_ERROR, "msiDigestMonStat :: &genQueryOut is NULL" );        return rei->status;    }    if ( status == 0 ) {        nresc = genQueryOut->rowCnt;        for ( i = 0; i < genQueryOut->attriCnt; i++ ) {            for ( j = 0; j < nresc; j++ ) {                tResult = genQueryOut->sqlResult[i].value;                tResult += j * genQueryOut->sqlResult[i].len;                if ( i == 0 ) {                    rstrcpy( rescList[j], tResult, genQueryOut->sqlResult[i].len );                }                if ( i == 1 ) {                    rstrcpy( timeList[j], tResult, genQueryOut->sqlResult[i].len );                }            }        }    }    else {        rodsLog( LOG_ERROR, "msiDigestMonStat: Unable to retrieve information /                        from R_SERVER_LOAD" );        return rei->status;    }    memset( &genQueryInp, 0, sizeof( genQueryInp ) );    addInxIval( &genQueryInp.selectInp, COL_SL_CPU_USED, 1 );    addInxIval( &genQueryInp.selectInp, COL_SL_MEM_USED, 1 );    addInxIval( &genQueryInp.selectInp, COL_SL_SWAP_USED, 1 );    addInxIval( &genQueryInp.selectInp, COL_SL_RUNQ_LOAD, 1 );    addInxIval( &genQueryInp.selectInp, COL_SL_DISK_SPACE, 1 );    addInxIval( &genQueryInp.selectInp, COL_SL_NET_INPUT, 1 );    addInxIval( &genQueryInp.selectInp, COL_SL_NET_OUTPUT, 1 );    genQueryInp.maxRows = 1;    generalRowInsertInp.tableName = "serverloaddigest";    for ( i = 0; i < nresc; i++ ) {        memset( &genQueryInp.sqlCondInp, 0, sizeof( genQueryInp.sqlCondInp ) );        snprintf( condStr1, MAX_NAME_LEN, "= '%s'", rescList[i] );        addInxVal( &genQueryInp.sqlCondInp, COL_SL_RESC_NAME, condStr1 );        snprintf( condStr2, MAX_NAME_LEN, "= '%s'", timeList[i] );        addInxVal( &genQueryInp.sqlCondInp, COL_SL_CREATE_TIME, condStr2 );        status =  rsGenQuery( rsComm, &genQueryInp, &genQueryOut );        if ( status == 0 ) {            loadFactor = 0;            for ( j = 0; j < genQueryOut->attriCnt; j++ ) {                tResult = genQueryOut->sqlResult[j].value;                loadFactor += atoi( tResult ) * weight[j];            }            loadFactor = loadFactor / totalWeight;            generalRowInsertInp.arg1 = rescList[i];            snprintf( loadStr, MAX_NAME_LEN, "%i", loadFactor );            generalRowInsertInp.arg2 = loadStr;            rc = rsGeneralRowInsert( rsComm, &generalRowInsertInp );            if ( rc != 0 ) {                rodsLog( LOG_ERROR, "msiDigestMonStat: Unable to ingest/        information into from R_SERVER_LOAD_DIGEST table" );            }        }

int rodsMonPerfLog( char *serverName, char *resc, char *output, ruleExecInfo_t *rei ) {    char condstr[MAX_NAME_LEN], fname[MAX_NAME_LEN], msg[MAX_MESSAGE_SIZE],         monStatus[MAX_NAME_LEN], suffix[MAX_VALUE], *result;    const char *delim1 = "#";    const char *delim2 = ",";    int index, timestamp, rc1 = 0, rc2 = 0, rc3 = 0, rc4 = 0;    FILE *foutput;    time_t tps;    generalRowInsertInp_t generalRowInsertInp;    generalAdminInp_t generalAdminInp1, generalAdminInp2;    genQueryInp_t genQueryInp;    struct tm *now;    genQueryOut_t *genQueryOut = NULL;    tps = time( NULL );    now = localtime( &tps );    /* a quick test in order to see if the resource is up or down (needed to update the "status" metadata) */    if ( strcmp( output, MON_OUTPUT_NO_ANSWER ) == 0 ) {        strncpy( monStatus, RESC_AUTO_DOWN, MAX_NAME_LEN );    }    else {        strncpy( monStatus, RESC_AUTO_UP, MAX_NAME_LEN );    }    std::vector<std::string> output_tokens;    boost::algorithm::split( output_tokens, output, boost::is_any_of( delim1 ) );    std::vector<std::string> resc_tokens;    boost::algorithm::split( resc_tokens, resc, boost::is_any_of( delim2 ) );    std::vector<std::string> disk_tokens;    boost::algorithm::split( disk_tokens, output_tokens[4], boost::is_any_of( delim2 ) );    std::vector<std::string> value_tokens;    boost::algorithm::split( value_tokens, output_tokens[7], boost::is_any_of( delim2 ) );    index = 0;    while ( !resc_tokens[index].empty() ) {        if ( strcmp( monStatus, RESC_AUTO_DOWN ) == 0 ) {            disk_tokens[index] = "-1";            value_tokens[index] = "-1";        }        sprintf( msg, "server=%s resource=%s cpu=%s, mem=%s, swp=%s, rql=%s, dsk=%s, nin=%s, nout=%s, dskAv(MB)=%s/n",                 serverName, resc_tokens[index].c_str(), output_tokens[0].c_str(), output_tokens[1].c_str(), output_tokens[2].c_str(),                 output_tokens[3].c_str(), disk_tokens[index].c_str(), output_tokens[5].c_str(), output_tokens[6].c_str(), value_tokens[index].c_str() );        sprintf( suffix, "%d.%d.%d", now->tm_year + 1900, now->tm_mon + 1, now->tm_mday );        sprintf( fname, "%s.%s", OUTPUT_MON_PERF, suffix );        /* retrieve the system time */        timestamp = time( &tps );        /* log the result into the database as well */        generalRowInsertInp.tableName = "serverload";        generalRowInsertInp.arg1 = serverName;        generalRowInsertInp.arg2 = resc_tokens[index].c_str();        generalRowInsertInp.arg3 = output_tokens[0].c_str();        generalRowInsertInp.arg4 = output_tokens[1].c_str();        generalRowInsertInp.arg5 = output_tokens[2].c_str();        generalRowInsertInp.arg6 = output_tokens[3].c_str();        generalRowInsertInp.arg7 = disk_tokens[index].c_str();        generalRowInsertInp.arg8 = output_tokens[5].c_str();        generalRowInsertInp.arg9 = output_tokens[6].c_str();        /* prepare DB request to modify resource metadata: freespace and status */        generalAdminInp1.arg0 = "modify";        generalAdminInp1.arg1 = "resource";        generalAdminInp1.arg2 = resc_tokens[index].c_str();        generalAdminInp1.arg3 = "freespace";        generalAdminInp1.arg4 = value_tokens[index].c_str();        generalAdminInp2.arg0 = "modify";        generalAdminInp2.arg1 = "resource";        generalAdminInp2.arg2 = resc_tokens[index].c_str();        generalAdminInp2.arg3 = "status";        generalAdminInp2.arg4 = monStatus;        memset( &genQueryInp, 0, sizeof( genQueryInp ) );        addInxIval( &genQueryInp.selectInp, COL_R_RESC_STATUS, 1 );        snprintf( condstr, MAX_NAME_LEN, "= '%s'", resc_tokens[index].c_str() );        addInxVal( &genQueryInp.sqlCondInp, COL_R_RESC_NAME, condstr );        genQueryInp.maxRows = MAX_SQL_ROWS;#ifndef windows_platform        pthread_mutex_lock( &my_mutex );#endif        /* append to the output log file */        foutput = fopen( fname, "a" );        if ( foutput != NULL ) {            fprintf( foutput, "time=%i %s", timestamp, msg );            // fclose(foutput); // JMC cppcheck - nullptr // cannot close it here. it is used later - hcj        }        rc1 = rsGeneralRowInsert( rei->rsComm, &generalRowInsertInp );        rc2 = rsGeneralAdmin( rei->rsComm, &generalAdminInp1 );        rc3 = rsGenQuery( rei->rsComm, &genQueryInp, &genQueryOut );        if ( rc3 >= 0 ) {            result = genQueryOut->sqlResult[0].value;            if ( strcmp( result, "/0" ) == 0 || ( strncmp( result, "auto-", 5 ) == 0 && strcmp( result, monStatus ) != 0 ) ) {                rc4 = rsGeneralAdmin( rei->rsComm, &generalAdminInp2 );            }        }        else {            rodsLog( LOG_ERROR, "msiServerMonPerf: unable to retrieve the status metadata for the resource %s", resc_tokens[index].c_str() );        }#ifndef windows_platform        pthread_mutex_unlock( &my_mutex );#endif//.........这里部分代码省略.........

int getListOfResc( rsComm_t *rsComm, char serverList[MAX_VALUE][MAX_NAME_LEN], int nservers,                   monInfo_t monList[MAX_NSERVERS], int *nlist ) {    /**********************************************************     * search in the database, the list of resources with      *     * their associated server. If config file exist, restrict *     * the list to serverList                                  *     ***********************************************************/    int i, j, k, index[MAX_NSERVERS], l, status;    genQueryInp_t genQueryInp;    genQueryOut_t *genQueryOut = NULL;    char condStr[MAX_NAME_LEN];    memset( &genQueryInp, 0, sizeof( genQueryInp_t ) );    memset( &index, -1, MAX_NSERVERS * sizeof( int ) );    genQueryInp.maxRows = MAX_SQL_ROWS;    //clearGenQueryInp( &genQueryInp );    addInxIval( &genQueryInp.selectInp, COL_R_LOC, 1 );    addInxIval( &genQueryInp.selectInp, COL_R_RESC_NAME, 1 );    addInxIval( &genQueryInp.selectInp, COL_R_TYPE_NAME, 1 );    addInxIval( &genQueryInp.selectInp, COL_R_VAULT_PATH, 1 );    addInxVal( &genQueryInp.sqlCondInp, COL_R_LOC, "!='EMPTY_RESC_HOST'" );    addInxVal( &genQueryInp.sqlCondInp, COL_R_VAULT_PATH, "!='EMPTY_RESC_PATH'" );    snprintf( condStr, MAX_NAME_LEN, "!='%s'", BUNDLE_RESC );    addInxVal( &genQueryInp.sqlCondInp, COL_R_RESC_NAME, condStr );    status = rsGenQuery( rsComm, &genQueryInp, &genQueryOut );    if ( status < 0 ) {        irods::log( ERROR( status, "rsGenQuery failed." ) );    }    if ( genQueryOut->rowCnt > 0 ) {        l = 0;        for ( i = 0; i < genQueryOut->attriCnt; i++ ) {            for ( j = 0; j < genQueryOut->rowCnt; j++ ) {                char *tResult;                tResult = genQueryOut->sqlResult[i].value;                tResult += j * genQueryOut->sqlResult[i].len;                switch ( i ) {                case 0:                    if ( nservers >= 0 ) {                        for ( k = 0; k < nservers; k++ ) {                            if ( strcmp( serverList[k], tResult ) == 0 ) {                                index[j] = l;                                l++;                            }                        }                    }                    else {                        index[j] = l;                        l++;                    }                    if ( index[j] != -1 ) {                        rstrcpy( monList[index[j]].serverName, tResult, LONG_NAME_LEN );                    }                    break;                case 1:                    if ( index[j] != -1 ) {                        rstrcpy( monList[index[j]].rescName, tResult, MAX_NAME_LEN );                    }                    break;                case 2:                    if ( index[j] != -1 ) {                        rstrcpy( monList[index[j]].rescType, tResult, LONG_NAME_LEN );                    }                    break;                case 3:                    if ( index[j] != -1 ) {                        rstrcpy( monList[index[j]].vaultPath, tResult, LONG_NAME_LEN );                    }                    break;                }            }        }        ( *nlist ) = l;        clearGenQueryInp( &genQueryInp );        freeGenQueryOut( &genQueryOut );        return 0;    }    return -1;}