C++ rsGenQuery函数代码示例

int
isColl( 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;
}

int
checkPermitForDataObject( 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 );
}

int
getReInfoById( 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;
}

int
getQuotaByResc( 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;
}

int
getTokenId(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;

}

int
getUserId( 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;
}

int
checkPermitForResource( 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 4552
int
getNumSubfilesInBunfileObj( 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 */
int
checkDupReplica( 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;
}

int
isData(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;

}