int unpackReiAndArg (rsComm_t *rsComm, ruleExecInfoAndArg_t **reiAndArg, bytesBuf_t *packedReiAndArgBBuf) { int status; /*ruleExecInfo_t *myRei;*/ if (packedReiAndArgBBuf == NULL || reiAndArg == NULL) { return (SYS_INTERNAL_NULL_INPUT_ERR); } /* unpack the reiAndArg */ status = unpackStruct (packedReiAndArgBBuf->buf, (void **) reiAndArg, "ReiAndArg_PI", RodsPackTable, NATIVE_PROT); if (status < 0) { rodsLog (LOG_ERROR, "unpackReiAndArg: unpackStruct error. status = %d", status); return (status); } /* try to touch up the unpacked rei */ status = touchupPackedRei (rsComm, (*reiAndArg)->rei); return (status); }
int unpackRei (rsComm_t *rsComm, ruleExecInfo_t **rei, bytesBuf_t *packedReiBBuf) { int status; if (packedReiBBuf == NULL || rei == NULL) { return (SYS_INTERNAL_NULL_INPUT_ERR); } /* unpack the rei */ /* alway use NATIVE_PROT for rei */ status = unpackStruct (packedReiBBuf->buf, (void **) rei, "Rei_PI", RodsPackTable, NATIVE_PROT); if (status < 0) { rodsLog (LOG_ERROR, "unpackRei: unpackStruct error. status = %d", status); return (status); } /* try to touch up the unpacked rei */ status = touchupPackedRei (rsComm, *rei); return (status); }
// =-=-=-=-=-=-=- // irods::error readMsgHeader( irods::network_object_ptr _ptr, msgHeader_t* _header, struct timeval* _time_val ) { // =-=-=-=-=-=-=- // resolve a network interface plugin from the // network object irods::plugin_ptr p_ptr; irods::error ret_err = _ptr->resolve( irods::NETWORK_INTERFACE, p_ptr ); if ( !ret_err.ok() ) { return PASSMSG( "failed to resolve network interface", ret_err ); } // =-=-=-=-=-=-=- // make the call to the "read" interface char tmp_buf[ MAX_NAME_LEN ]; irods::first_class_object_ptr ptr = boost::dynamic_pointer_cast< irods::first_class_object >( _ptr ); irods::network_ptr net = boost::dynamic_pointer_cast< irods::network >( p_ptr ); ret_err = net->call< void*, struct timeval* >( irods::NETWORK_OP_READ_HEADER, ptr, tmp_buf, _time_val ); // =-=-=-=-=-=-=- // pass along an error from the interface or return SUCCESS if ( !ret_err.ok() ) { return PASSMSG( "failed to call 'read header'", ret_err ); } // =-=-=-=-=-=-=- // unpack the header message, always use XML_PROT for the header msgHeader_t* out_header = 0; int status = unpackStruct( static_cast<void*>( tmp_buf ), ( void ** )( static_cast< void * >( &out_header ) ), "MsgHeader_PI", RodsPackTable, XML_PROT ); if ( status < 0 ) { return ERROR( status, "unpackStruct error" ); } if ( !out_header ) { return ERROR( -1, "" ); } // =-=-=-=-=-=-=- // need to do an assignment due to something potentially going out // of scope from unpackStruct. // NOTE :: look into why this is necessary *_header = *out_header; free( out_header ); // =-=-=-=-=-=-=- // win! return SUCCESS(); } // readMsgHeader
int readAggInfo (rsComm_t *rsComm, char *aggColl, keyValPair_t *condInput, ncAggInfo_t **ncAggInfo) { int status; dataObjInp_t dataObjInp; bytesBuf_t packedBBuf; portalOprOut_t *portalOprOut = NULL; bzero (&dataObjInp, sizeof (dataObjInp)); bzero (&packedBBuf, sizeof (packedBBuf)); if (condInput != NULL) replKeyVal (condInput, &dataObjInp.condInput); snprintf (dataObjInp.objPath, MAX_NAME_LEN, "%s/%s", aggColl, NC_AGG_INFO_FILE_NAME); dataObjInp.oprType = GET_OPR; status = rsDataObjGet (rsComm, &dataObjInp, &portalOprOut, &packedBBuf); clearKeyVal (&dataObjInp.condInput); if (portalOprOut != NULL) free (portalOprOut); if (status < 0) { if (status == CAT_NO_ROWS_FOUND) status = NETCDF_AGG_INFO_FILE_ERR; rodsLogError (LOG_ERROR, status, "readAggInfo: rsDataObjGet error for %s", dataObjInp.objPath); return status; } status = unpackStruct (packedBBuf.buf, (void **) ncAggInfo, "NcAggInfo_PI", RodsPackTable, XML_PROT); if (status < 0) { rodsLogError (LOG_ERROR, status, "readAggInfo: unpackStruct error for %s", dataObjInp.objPath); return NETCDF_AGG_INFO_FILE_ERR; } if (*ncAggInfo == NULL || (*ncAggInfo)->numFiles == 0) { rodsLog (LOG_ERROR, "readAggInfo: No ncAggInfo for %s", dataObjInp.objPath); return NETCDF_AGG_INFO_FILE_ERR; } return status; }
int rsApiHandler( rsComm_t* rsComm, int apiNumber, bytesBuf_t* inputStructBBuf, bytesBuf_t* bsBBuf ) { int apiInx; int status = 0; char *myInStruct = NULL; funcPtr myHandler = NULL; void *myOutStruct = NULL; bytesBuf_t myOutBsBBuf; int retVal = 0; int numArg = 0; void *myArgv[4]; memset( &myOutBsBBuf, 0, sizeof( bytesBuf_t ) ); memset( &rsComm->rError, 0, sizeof( rError_t ) ); apiInx = apiTableLookup( apiNumber ); // =-=-=-=-=-=-=- // create a network object irods::network_object_ptr net_obj; irods::error ret = irods::network_factory( rsComm, net_obj ); if ( !ret.ok() ) { irods::log( PASS( ret ) ); return apiInx; } if ( apiInx < 0 ) { rodsLog( LOG_ERROR, "rsApiHandler: apiTableLookup of apiNumber %d failed", apiNumber ); /* cannot use sendApiReply because it does not know apiInx */ sendRodsMsg( net_obj, RODS_API_REPLY_T, NULL, NULL, NULL, apiInx, rsComm->irodsProt ); return apiInx; } rsComm->apiInx = apiInx; status = chkApiVersion( apiInx ); if ( status < 0 ) { sendApiReply( rsComm, apiInx, status, myOutStruct, &myOutBsBBuf ); return status; } status = chkApiPermission( rsComm, apiInx ); if ( status < 0 ) { rodsLog( LOG_NOTICE, "rsApiHandler: User has no permission for apiNumber %d", apiNumber ); sendApiReply( rsComm, apiInx, status, myOutStruct, &myOutBsBBuf ); return status; } irods::api_entry_table& RsApiTable = irods::get_server_api_table(); /* some sanity check */ if ( inputStructBBuf->len > 0 && RsApiTable[apiInx]->inPackInstruct == NULL ) { rodsLog( LOG_NOTICE, "rsApiHandler: input struct error 1 for apiNumber %d", apiNumber ); sendApiReply( rsComm, apiInx, SYS_API_INPUT_ERR, myOutStruct, &myOutBsBBuf ); return SYS_API_INPUT_ERR; } if ( inputStructBBuf->len <= 0 && RsApiTable[apiInx]->inPackInstruct != NULL ) { rodsLog( LOG_NOTICE, "rsApiHandler: input struct error 2 for apiNumber %d", apiNumber ); sendApiReply( rsComm, apiInx, SYS_API_INPUT_ERR, myOutStruct, &myOutBsBBuf ); return SYS_API_INPUT_ERR; } if ( bsBBuf->len > 0 && RsApiTable[apiInx]->inBsFlag <= 0 ) { rodsLog( LOG_NOTICE, "rsApiHandler: input byte stream error for apiNumber %d", apiNumber ); sendApiReply( rsComm, apiInx, SYS_API_INPUT_ERR, myOutStruct, &myOutBsBBuf ); return SYS_API_INPUT_ERR; } if ( inputStructBBuf->len > 0 ) { status = unpackStruct( inputStructBBuf->buf, ( void ** )( static_cast< void * >( &myInStruct ) ), ( char* )RsApiTable[apiInx]->inPackInstruct, RodsPackTable, rsComm->irodsProt ); if ( status < 0 ) { rodsLog( LOG_NOTICE, "rsApiHandler: unpackStruct error for apiNumber %d, status = %d", apiNumber, status ); sendApiReply( rsComm, apiInx, status, myOutStruct, &myOutBsBBuf ); return status; } } /* ready to call the handler functions */ myHandler = RsApiTable[apiInx]->svrHandler; if ( !myHandler ) { rodsLog( LOG_ERROR, "Null handler encountered for api number %d in rsApiHandler.", apiNumber ); return SYS_API_INPUT_ERR; } if ( RsApiTable[apiInx]->inPackInstruct != NULL ) { myArgv[numArg] = myInStruct; numArg++; }; if ( RsApiTable[apiInx]->inBsFlag != 0 ) { myArgv[numArg] = bsBBuf; numArg++; }; if ( RsApiTable[apiInx]->outPackInstruct != NULL ) { myArgv[numArg] = ( void * ) &myOutStruct; numArg++; }; if ( RsApiTable[apiInx]->outBsFlag != 0 ) { myArgv[numArg] = ( void * ) &myOutBsBBuf; numArg++; }; if ( numArg == 0 ) { retVal = ( *myHandler )( rsComm ); } else if ( numArg == 1 ) { retVal = ( *myHandler )( rsComm, myArgv[0] ); } else if ( numArg == 2 ) { retVal = ( *myHandler )( rsComm, myArgv[0], myArgv[1] ); } else if ( numArg == 3 ) { retVal = ( *myHandler )( rsComm, myArgv[0], myArgv[1], myArgv[2] ); } else if ( numArg == 4 ) { retVal = ( *myHandler )( rsComm, myArgv[0], myArgv[1], myArgv[2], myArgv[3] ); } if ( retVal != SYS_NO_HANDLER_REPLY_MSG ) { status = sendAndProcApiReply ( rsComm, apiInx, retVal, myOutStruct, &myOutBsBBuf ); } // =-=-=-=-=-=-=- // clear the incoming packing instruction if ( myInStruct != NULL ) { if ( RsApiTable[apiInx]->clearInStruct ) { RsApiTable[apiInx]->clearInStruct( myInStruct ); } free( myInStruct ); myInStruct = NULL; } if ( retVal >= 0 && status < 0 ) { return status; } else { return retVal; } }
// =-=-=-=-=-=-=- // irods::error readVersion( irods::network_object_ptr _ptr, version_t** _version ) { // =-=-=-=-=-=-=- // init timval struct for header call struct timeval tv; tv.tv_sec = READ_VERSION_TOUT_SEC; tv.tv_usec = 0; // =-=-=-=-=-=-=- // call interface to read message header msgHeader_t myHeader; irods::error ret = readMsgHeader( _ptr, &myHeader, &tv ); if ( !ret.ok() ) { return PASS( ret ); } // =-=-=-=-=-=-=- // call interface to read message body bytesBuf_t inputStructBBuf, bsBBuf, errorBBuf; memset( &bsBBuf, 0, sizeof( bytesBuf_t ) ); ret = readMsgBody( _ptr, &myHeader, &inputStructBBuf, &bsBBuf, &errorBBuf, XML_PROT, NULL ); if ( !ret.ok() ) { return PASS( ret ); } // =-=-=-=-=-=-=- // basic error checking of message type if ( strcmp( myHeader.type, RODS_VERSION_T ) != 0 ) { if ( inputStructBBuf.buf != NULL ) { free( inputStructBBuf.buf ); } if ( bsBBuf.buf != NULL ) { free( bsBBuf.buf ); } if ( errorBBuf.buf != NULL ) { free( errorBBuf.buf ); } std::stringstream msg; msg << "wrong msg type [" << myHeader.type << " expected [" << RODS_VERSION_T << "]"; return ERROR( SYS_HEADER_TYPE_LEN_ERR, msg.str() ); } // =-=-=-=-=-=-=- // check length of byte stream buffer, should be 0 if ( myHeader.bsLen != 0 ) { if ( bsBBuf.buf != NULL ) { free( bsBBuf.buf ); } rodsLog( LOG_NOTICE, "readVersion: myHeader.bsLen = %d is not 0", myHeader.bsLen ); } // =-=-=-=-=-=-=- // check length of error buffer, should be 0 if ( myHeader.errorLen != 0 ) { if ( errorBBuf.buf != NULL ) { free( errorBBuf.buf ); } rodsLog( LOG_NOTICE, "readVersion: myHeader.errorLen = %d is not 0", myHeader.errorLen ); } // =-=-=-=-=-=-=- // bounds check message size if ( myHeader.msgLen > ( int ) sizeof( version_t ) * 2 || myHeader.msgLen <= 0 ) { if ( inputStructBBuf.buf != NULL ) { free( inputStructBBuf.buf ); } std::stringstream msg; msg << "header length is not within bounds: " << myHeader.msgLen; return ERROR( SYS_HEADER_READ_LEN_ERR, msg.str() ); } // =-=-=-=-=-=-=- // unpack the message, always use XML for this message type int status = unpackStruct( inputStructBBuf.buf, ( void** )( _version ), "Version_PI", RodsPackTable, XML_PROT ); free( inputStructBBuf.buf ); if ( status < 0 ) { rodsLogError( LOG_NOTICE, status, "readVersion:unpackStruct error. status = %d", status ); } return CODE( status ); } // readVersion
// =-=-=-=-=-=-=- // irods::error readReconMsg( irods::network_object_ptr _ptr, reconnMsg_t** _msg ) { int status; msgHeader_t myHeader; bytesBuf_t inputStructBBuf, bsBBuf, errorBBuf; // =-=-=-=-=-=-=- // irods::error ret = readMsgHeader( _ptr, &myHeader, NULL ); if ( !ret.ok() ) { return PASSMSG( "read msg header error", ret ); } memset( &bsBBuf, 0, sizeof( bytesBuf_t ) ); ret = readMsgBody( _ptr, &myHeader, &inputStructBBuf, &bsBBuf, &errorBBuf, XML_PROT, NULL ); if ( !ret.ok() ) { return PASS( ret ); } /* some sanity check */ if ( strcmp( myHeader.type, RODS_RECONNECT_T ) != 0 ) { if ( inputStructBBuf.buf != NULL ) { free( inputStructBBuf.buf ); } if ( bsBBuf.buf != NULL ) { free( bsBBuf.buf ); } if ( errorBBuf.buf != NULL ) { free( errorBBuf.buf ); } std::stringstream msg; msg << "wrong msg type [" << myHeader.type << "] expected [" << RODS_CONNECT_T << "]"; return ERROR( SYS_HEADER_TYPE_LEN_ERR, msg.str() ); } if ( myHeader.bsLen != 0 ) { if ( bsBBuf.buf != NULL ) { free( bsBBuf.buf ); } rodsLog( LOG_NOTICE, "readReconMsg: myHeader.bsLen = %d is not 0", myHeader.bsLen ); } if ( myHeader.errorLen != 0 ) { if ( errorBBuf.buf != NULL ) { free( errorBBuf.buf ); } rodsLog( LOG_NOTICE, "readReconMsg: myHeader.errorLen = %d is not 0", myHeader.errorLen ); } if ( myHeader.msgLen <= 0 ) { if ( inputStructBBuf.buf != NULL ) { free( inputStructBBuf.buf ); } rodsLog( LOG_NOTICE, "readReconMsg: problem with myHeader.msgLen = %d", myHeader.msgLen ); std::stringstream msg; msg << "message length is invalid: " << myHeader.msgLen; return ERROR( SYS_HEADER_READ_LEN_ERR, msg.str() ); } /* always use XML_PROT for the startup pack */ status = unpackStruct( inputStructBBuf.buf, ( void** )( _msg ), "ReconnMsg_PI", RodsPackTable, XML_PROT ); clearBBuf( &inputStructBBuf ); if ( status < 0 ) { rodsLogError( LOG_NOTICE, status, "readReconMsg:unpackStruct error. status = %d", status ); } return CODE( status ); }
int main(int argc, char **argv) { int status; packItem_t *packItemHead = NULL; startupPack_t myStartupPack, *outStartupPack; rError_t myError, *outError; bytesBuf_t *packedResult; genQueryOut_t myQueryOut, *outQueryOut; char *tmpValue; int i; modDataObjMeta_t modDataObjMetaInp, *outModDataObjMeta; dataObjInfo_t dataObjInfo; keyValPair_t regParam; authCheckInp_t authCheckInp, *outAuthCheckInp; genQueryInp_t genQueryInp, *outGenQueryInp; irodsProt_t irodsProt = XML_PROT; memset (&genQueryInp, 0, sizeof (genQueryInp)); addInxVal (&genQueryInp.sqlCondInp, COL_COLL_NAME, "=xyz"); addInxIval (&genQueryInp.selectInp, COL_COLL_ID, 1); genQueryInp.maxRows = 1234567890; status = packStruct (&genQueryInp, &packedResult, "GenQueryInp_PI", NULL, 0, irodsProt); printf ("packStruct GenQueryInp_PI, status = %d\n", status); if (irodsProt == XML_PROT) writePackedRes (packedResult, "queryInp.out"); status = unpackStruct (packedResult->buf, (void **) &outGenQueryInp, "GenQueryInp_PI", NULL, irodsProt); printf ("unpackStruct of empty GenQueryInp_PI, status = %d\n", status); memset (&authCheckInp, 0, sizeof (authCheckInp)); status = packStruct (&authCheckInp, &packedResult, "authCheckInp_PI", NULL, 0, irodsProt); printf ("packStruct of empty authCheckInp_PI, status = %d\n", status); if (irodsProt == XML_PROT) writePackedRes (packedResult, "auth.out"); status = unpackStruct (packedResult->buf, (void **) &outAuthCheckInp, "authCheckInp_PI", NULL, irodsProt); printf ("unpackStruct of empty authCheckInp_PI, status = %d\n", status); memset (&dataObjInfo, 0, sizeof (dataObjInfo_t)); memset (®Param, 0, sizeof (keyValPair_t)); strcpy (dataObjInfo.objPath, "/tmp/thisIsATest"); modDataObjMetaInp.dataObjInfo = &dataObjInfo; modDataObjMetaInp.regParam = ®Param; status = packStruct (&modDataObjMetaInp, &packedResult, "ModDataObjMeta_PI", NULL, 0, irodsProt); printf ("packStruct of ModDataObjMeta_PI, status = %d\n", status); if (irodsProt == XML_PROT) writePackedRes (packedResult, "modeData.out"); status = unpackStruct (packedResult->buf, (void **) &outModDataObjMeta, "ModDataObjMeta_PI", NULL, irodsProt); printf ("unpackStruct of ModDataObjMeta_PI, status = %d\n", status); memset (&myQueryOut, 0, sizeof (myQueryOut)); /* pack and unpack empty struct */ status = packStruct (&myQueryOut, &packedResult, "GenQueryOut_PI", NULL, 0, irodsProt); printf ("packStruct empty myQueryOut status = %d\n", status); if (irodsProt == XML_PROT) writePackedRes (packedResult, "genq.out"); status = unpackStruct (packedResult->buf, (void **) &outQueryOut, "GenQueryOut_PI", NULL, irodsProt); printf ("unpackStruct empty myQueryOut status = %d\n", status); memset (&myQueryOut, 0, sizeof (myQueryOut)); myQueryOut.rowCnt = 2; myQueryOut.attriCnt = 4; myQueryOut.sqlResult[0].attriInx = 10; myQueryOut.sqlResult[0].len = 20; myQueryOut.sqlResult[0].value = tmpValue = (char *) malloc (20*2); sprintf (tmpValue, "value 0,1"); tmpValue += 20; sprintf (tmpValue, "value 0,2"); myQueryOut.sqlResult[1].attriInx = 20; myQueryOut.sqlResult[1].len = 30; myQueryOut.sqlResult[1].value = tmpValue = (char *) malloc (30*2); sprintf (tmpValue, "value 1,1"); tmpValue += 30; sprintf (tmpValue, "value 1,2"); myQueryOut.sqlResult[2].attriInx = 30; myQueryOut.sqlResult[2].len = 40; myQueryOut.sqlResult[2].value = tmpValue = (char *) malloc (40*2); sprintf (tmpValue, "value 2,1"); tmpValue += 40; sprintf (tmpValue, "value 2,2"); myQueryOut.sqlResult[3].attriInx = 40; myQueryOut.sqlResult[3].len = 50; myQueryOut.sqlResult[3].value = tmpValue = (char *) malloc (50*2); memset (tmpValue, 0, 50*2); status = packStruct (&myQueryOut, &packedResult, "GenQueryOut_PI", NULL, 0, irodsProt); printf ("packStruct status = %d\n", status); if (irodsProt == XML_PROT) writePackedRes (packedResult, "genq.out"); status = unpackStruct (packedResult->buf, (void **) &outQueryOut, "GenQueryOut_PI", NULL, irodsProt); printf ("unpackStruct status = %d\n", status); status = parsePackInstruct (TEST_PI, &packItemHead); printf ("parsePackInstruct status = %d\n", status); myStartupPack.connectCnt = 11; myStartupPack.irodsProt = XML_PROT; strcpy (myStartupPack.proxyUser, "proxyUser"); strcpy (myStartupPack.proxyRodsZone, "proxyRodsZone"); strcpy (myStartupPack.clientUser, "myclientUser"); strcpy (myStartupPack.clientRodsZone, "clientRodsZone"); strcpy (myStartupPack.relVersion, "relVersion"); strcpy (myStartupPack.apiVersion, "apiVersion"); strcpy (myStartupPack.option, "option"); status = packStruct (&myStartupPack, &packedResult, "StartupPack_PI", NULL, 0, XML_PROT); printf ("packStruct of StartupPack_PI status = %d\n", status); if (irodsProt == XML_PROT) writePackedRes (packedResult, "startup.out"); status = unpackStruct (packedResult->buf, (void **) &outStartupPack, "StartupPack_PI", NULL, irodsProt); printf ("unpackStruct of StartupPack_PI status = %d\n", status); myError.len = 3; myError.errMsg = (rErrMsg_t **) malloc (sizeof (void *) * 3); for (i = 0; i < 3; i++) { myError.errMsg[i] = (rErrMsg_t *) malloc (sizeof (rErrMsg_t)); sprintf (myError.errMsg[i]->msg, "error %d\n", i); myError.errMsg[i]->status = i; } status = packStruct (&myError, &packedResult, "RError_PI", NULL, 0, irodsProt); printf ("packStruct of RErrMsg_PI status = %d\n", status); if (irodsProt == XML_PROT) writePackedRes (packedResult, "error.out"); status = unpackStruct (packedResult->buf, (void **) &outError, "RError_PI", NULL, irodsProt); printf ("unpackStruct of RErrMsg_PI status = %d\n", status); }
int procApiReply( rcComm_t *conn, int apiInx, void **outStruct, bytesBuf_t *outBsBBuf, msgHeader_t *myHeader, bytesBuf_t *outStructBBuf, bytesBuf_t *myOutBsBBuf, bytesBuf_t *errorBBuf ) { int status; int retVal; if ( errorBBuf->len > 0 ) { status = unpackStruct( errorBBuf->buf, ( void ** )( static_cast< void * >( &conn->rError ) ), "RError_PI", RodsPackTable, conn->irodsProt ); if ( status < 0 ) { rodsLogError( LOG_ERROR, status, "readAndProcApiReply:unpackStruct error. status = %d", status ); } } retVal = myHeader->intInfo; /* some sanity check */ irods::api_entry_table& RcApiTable = irods::get_client_api_table(); if ( RcApiTable[apiInx]->outPackInstruct != NULL && outStruct == NULL ) { rodsLog( LOG_ERROR, "readAndProcApiReply: outStruct error for C apiNumber %d", RcApiTable[apiInx]->apiNumber ); if ( retVal < 0 ) { return retVal; } else { return ( USER_API_INPUT_ERR ); } } if ( RcApiTable[apiInx]->outBsFlag > 0 && outBsBBuf == NULL ) { rodsLog( LOG_ERROR, "readAndProcApiReply: outBsBBuf error for D apiNumber %d", RcApiTable[apiInx]->apiNumber ); if ( retVal < 0 ) { return retVal; } else { return ( USER_API_INPUT_ERR ); } } /* handle outStruct */ if ( outStructBBuf->len > 0 ) { if ( outStruct != NULL ) { status = unpackStruct( outStructBBuf->buf, ( void ** ) outStruct, ( char* )RcApiTable[apiInx]->outPackInstruct, RodsPackTable, conn->irodsProt ); if ( status < 0 ) { rodsLogError( LOG_ERROR, status, "readAndProcApiReply:unpackStruct error. status = %d", status ); if ( retVal < 0 ) { return retVal; } else { return ( status ); } } } else { rodsLog( LOG_ERROR, "readAndProcApiReply: got unneeded outStruct for apiNumber %d", RcApiTable[apiInx]->apiNumber ); } } if ( myOutBsBBuf != NULL && myOutBsBBuf->len > 0 ) { if ( outBsBBuf != NULL ) { /* copy to out */ *outBsBBuf = *myOutBsBBuf; memset( myOutBsBBuf, 0, sizeof( bytesBuf_t ) ); } else { rodsLog( LOG_ERROR, "readAndProcApiReply: got unneeded outBsBBuf for apiNumber %d", RcApiTable[apiInx]->apiNumber ); } } return retVal; }
/// =-=-=-=-=-=-=- /// @brief function which sends the negotiation message error read_client_server_negotiation_message( irods::network_object_ptr _ptr, boost::shared_ptr< cs_neg_t >& _cs_neg_msg ) { // =-=-=-=-=-=-=- // read the message header struct timeval tv; tv.tv_sec = READ_VERSION_TOUT_SEC; tv.tv_usec = 0; msgHeader_t msg_header; irods::error ret = readMsgHeader( _ptr, &msg_header, &tv ); if ( !ret.ok() ) { return PASSMSG( "read message header failed", ret ); } // =-=-=-=-=-=-=- // read the message body bytesBuf_t struct_buf, data_buf, error_buf; memset( &data_buf, 0, sizeof( bytesBuf_t ) ); ret = readMsgBody( _ptr, &msg_header, &struct_buf, &data_buf, &error_buf, XML_PROT, 0 ); if ( !ret.ok() ) { return PASS( ret ); } // =-=-=-=-=-=-=- // check that we did in fact get the right type of message if ( strcmp( msg_header.type, RODS_CS_NEG_T ) != 0 ) { // =-=-=-=-=-=-=- // trap potential case where server does not support // advanced negotiation. a version msg would be sent // back instead. if ( strcmp( msg_header.type, RODS_VERSION_T ) == 0 ) { // =-=-=-=-=-=-=- // unpack the version struct to check the status version_t* version = 0; int status = unpackStruct( struct_buf.buf, ( void ** )( static_cast<void *>( &version ) ), "Version_PI", RodsPackTable, XML_PROT ); if ( struct_buf.buf ) { free( struct_buf.buf ); } if ( data_buf.buf ) { free( data_buf.buf ); } if ( error_buf.buf ) { free( error_buf.buf ); } if ( status < 0 ) { rodsLog( LOG_ERROR, "read_client_server_negotiation_message :: unpackStruct FAILED" ); return ERROR( status, "unpackStruct failed" ); } if ( version->status < 0 ) { rodsLog( LOG_ERROR, "read_client_server_negotiation_message :: received error message %d", version->status ); return ERROR( version->status, "negotiation failed" ); } else { // =-=-=-=-=-=-=- // if no negoation is allowed then provide a readable // error for the client std::stringstream msg; msg << "received [" << msg_header.type << "] "; msg << "but expected [" << RODS_CS_NEG_T << "]\n\n"; msg << "\t*** Advanced negotiation is enabled in this iRODS environment ***\n"; msg << "\t*** which is most likely not supported by the server. ***\n"; msg << "\t*** Comment out irodsClientServerNegotiation in the irodsEnv ***\n"; msg << "\t*** file to disable. ***\n"; return ERROR( ADVANCED_NEGOTIATION_NOT_SUPPORTED, msg.str() ); } } else { // =-=-=-=-=-=-=- // something entirely unexpected happened std::stringstream msg; msg << "wrong message type [" << msg_header.type << "] "; msg << "expected [" << RODS_CS_NEG_T << "]"; return ERROR( SYS_HEADER_TYPE_LEN_ERR, msg.str() ); } } // =-=-=-=-=-=-=- // check that we did not get any data with the message if ( msg_header.bsLen != 0 ) { if ( data_buf.buf != NULL ) { free( data_buf.buf ); } rodsLog( LOG_NOTICE, "read_client_server_negotiation_message: msg_header.bsLen = %d is not 0", msg_header.bsLen ); } // =-=-=-=-=-=-=- // check that we did not get anything in the error buffer if ( msg_header.errorLen != 0 ) { if ( error_buf.buf ) { free( error_buf.buf ); } rodsLog( LOG_NOTICE, "read_client_server_negotiation_message: msg_header.errorLen = %d is not 0", msg_header.errorLen ); } // =-=-=-=-=-=-=- // check that we did get an appropriately sized message if ( msg_header.msgLen > ( int ) sizeof( irods::cs_neg_t ) * 2 || msg_header.msgLen <= 0 ) { if ( struct_buf.buf != NULL ) { free( struct_buf.buf ); } std::stringstream msg; msg << "message length is invalid: " << msg_header.msgLen << " vs " << sizeof( irods::cs_neg_t ); return ERROR( SYS_HEADER_READ_LEN_ERR, msg.str() ); } // =-=-=-=-=-=-=- // do an unpack into our out variable using the xml protocol cs_neg_t* tmp_cs_neg = 0; int status = unpackStruct( struct_buf.buf, ( void ** )( static_cast<void *>( &tmp_cs_neg ) ), "CS_NEG_PI", RodsPackTable, XML_PROT ); free( struct_buf.buf ); if ( status < 0 ) { rodsLog( LOG_ERROR, "read_client_server_negotiation_message :: unpackStruct FAILED" ); return ERROR( status, "unpackStruct failed" ); } _cs_neg_msg.reset( tmp_cs_neg, free ); // =-=-=-=-=-=-=- // win!!!111one return SUCCESS(); } // read_client_server_negotiation_message