void choose_server(rcComm_t **cn, char *host, rodsEnv *env, int verb) {
if (verb) {
fprintf(stderr, "Chosen server is: %s\n", host);
}
if (host && strcmp(host, THIS_ADDRESS)) {
int stat;
rErrMsg_t err_msg;
rcComm_t *new_cn = NULL;
new_cn = rcConnect(host, env->rodsPort, env->rodsUserName,
env->rodsZone, 0, &err_msg);
if (!new_cn) {
fprintf(stderr, "Error: rcReconnect failed with status %d. Continuing with original server.\n", err_msg.status);
return;
}
#if IRODS_VERSION_INTEGER && IRODS_VERSION_INTEGER >= 4001008
stat = clientLogin(new_cn, "", "");
#else
stat = clientLogin(new_cn);
#endif
if (stat < 0) {
rcDisconnect(new_cn);
error_and_exit(*cn, "Error: clientLogin failed with status %d:%s\n", stat, get_irods_error_name(stat, verb));
} else {
rcDisconnect(*cn);
*cn = new_cn;
}
}
}
static int irods_init()
{
kstring_t useragent = { 0, 0, NULL };
struct sigaction pipehandler;
rErrMsg_t err;
int ret, pipehandler_ret;
if (hts_verbose >= 5) rodsLogLevel(hts_verbose);
ret = getRodsEnv(&irods.env);
if (ret < 0) goto error;
// Set iRODS User-Agent, if our caller hasn't already done so.
kputs("htslib/", &useragent);
kputs(hts_version(), &useragent);
(void) setenv(SP_OPTION, useragent.s, 0);
free(useragent.s);
// Prior to iRODS 4.1, rcConnect() (even if it fails) installs its own
// SIGPIPE handler, which just prints a message and otherwise ignores the
// signal. Most actual SIGPIPEs encountered will pertain to e.g. stdout
// rather than iRODS's connection, so we save and restore the existing
// state (by default, termination; or as already set by our caller).
pipehandler_ret = sigaction(SIGPIPE, NULL, &pipehandler);
irods.conn = rcConnect(irods.env.rodsHost, irods.env.rodsPort,
irods.env.rodsUserName, irods.env.rodsZone,
NO_RECONN, &err);
if (pipehandler_ret == 0) sigaction(SIGPIPE, &pipehandler, NULL);
if (irods.conn == NULL) { ret = err.status; goto error; }
if (strcmp(irods.env.rodsUserName, PUBLIC_USER_NAME) != 0) {
#if defined IRODS_VERSION_INTEGER && IRODS_VERSION_INTEGER >= 4000000
ret = clientLogin(irods.conn, NULL, NULL);
#else
ret = clientLogin(irods.conn);
#endif
if (ret != 0) goto error;
}
return 0;
error:
if (irods.conn) { (void) rcDisconnect(irods.conn); }
irods.conn = NULL;
set_errno(ret);
return -1;
}
int
rcReconnect( rcComm_t **conn, char *newHost, rodsEnv *myEnv, int reconnFlag ) {
int status;
rcComm_t *newConn = NULL;
rErrMsg_t errMsg;
bzero( &errMsg, sizeof( errMsg ) );
newConn = rcConnect( newHost, myEnv->rodsPort, myEnv->rodsUserName,
myEnv->rodsZone, reconnFlag, &errMsg );
if ( newConn != NULL ) {
status = clientLogin( newConn );
if ( status != 0 ) {
rcDisconnect( newConn );
return status;
}
rcDisconnect( *conn );
*conn = newConn;
return 0;
}
else {
return errMsg.status;
}
}
int
isioSetup() {
int status;
rErrMsg_t errMsg;
char *mySubName;
char *myName;
if (debug) printf("isioSetup\n");
status = getRodsEnv (&myRodsEnv);
if (status < 0) {
rodsLogError(LOG_ERROR, status, "isioSetup: getRodsEnv error.");
}
Comm = rcConnect (myRodsEnv.rodsHost, myRodsEnv.rodsPort,
myRodsEnv.rodsUserName,
myRodsEnv.rodsZone, 0, &errMsg);
if (Comm == NULL) {
myName = rodsErrorName(errMsg.status, &mySubName);
rodsLog(LOG_ERROR, "rcConnect failure %s (%s) (%d) %s",
myName,
mySubName,
errMsg.status,
errMsg.msg);
status = errMsg.status;
return(status);
}
status = clientLogin(Comm);
if (status==0) {
setupFlag=1;
}
return(status);
}
int
ifuseConnect( iFuseConn_t *iFuseConn, rodsEnv *myRodsEnv ) {
int status = 0;
LOCK_STRUCT( *iFuseConn );
if ( iFuseConn->conn == NULL ) {
rErrMsg_t errMsg;
iFuseConn->conn = rcConnect( myRodsEnv->rodsHost, myRodsEnv->rodsPort,
myRodsEnv->rodsUserName, myRodsEnv->rodsZone, NO_RECONN, &errMsg );
if ( iFuseConn->conn == NULL ) {
/* try one more */
iFuseConn->conn = rcConnect( myRodsEnv->rodsHost, myRodsEnv->rodsPort,
myRodsEnv->rodsUserName, myRodsEnv->rodsZone, NO_RECONN, &errMsg );
if ( iFuseConn->conn == NULL ) {
rodsLogError( LOG_ERROR, errMsg.status,
"ifuseConnect: rcConnect failure %s", errMsg.msg );
UNLOCK_STRUCT( *iFuseConn );
if ( errMsg.status < 0 ) {
return errMsg.status;
}
else {
return -1;
}
}
}
status = clientLogin( iFuseConn->conn );
if ( status != 0 ) {
rcDisconnect( iFuseConn->conn );
iFuseConn->conn = NULL;
}
}
UNLOCK_STRUCT( *iFuseConn );
return status;
}
int RodsConnection::login()
{
int status = 0;
// first of all, we must be connected
if (!this->rodsCommPtr)
return (status);
// login only if not already logged in
if (!this->isReady())
{
this->mutexLock();
// try to authenticate client to the iRODS server
if ((status = clientLogin (this->rodsCommPtr)) != 0)
{
rcDisconnect(this->rodsCommPtr);
this->rodsCommPtr = NULL;
}
this->mutexUnlock();
}
return (status);
}
void connection::sendIdent(const QString &password)
{
clientIdentification clientLogin(icqUin, m_profile_name);
clientLogin.setProcolVersion(protocolVersion);
clientLogin.setScreenName(icqUin);
//clientLogin.setClientName("ICQ Client");
clientLogin.setPassword(password);
clientLogin.sendPacket(socket);
}
void main()
{
InitWinSock();
primarySock = mksocket();
sockaddr_in service;
service.sin_family = AF_INET;
service.sin_addr.s_addr = htonl(INADDR_ANY);
service.sin_port = htons(SERVER_PORT);
if (bind( primarySock, (SOCKADDR*) &service, sizeof(service)) == SOCKET_ERROR)
{
printf("bind() failed.\n");
closesocket(primarySock);
return;
}
sockaddr_in sender;
int senderlen = sizeof(sender);
stMessage recvMessage;
cout <<"recving..."<<endl;
for(;;)
{
int iret = recvfrom(primarySock,(char*)&recvMessage,sizeof(stMessage),0,(SOCKADDR *)&sender,&senderlen);
if(iret < 0)
{
cout << "recv data error!"<<endl;
}else
{
int type = recvMessage.iMessageType;
switch(type)
{
case LOGIN:
clientLogin(&recvMessage,&sender);
getUserList(sender);
break;
case LOGOUT:
removeUser(recvMessage.message.loginoutMessage.stUserName);
break;
case GETUSERLIST:
{
stP2PMessage command;
command.iMessageType = GETUSERLIST;
sendto(primarySock,(const char *)&command,sizeof(stP2PMessage),0,(const SOCKADDR *)&sender,senderlen);
getUserList(sender);
break;
}
case P2PTRAN:
P2PTran(recvMessage.message.translateMessage.stUserName,primarySock,sender);
break;
}
}
}
getchar();
}
//----------------------------------------------------------------------//
void CClient::readyRead()
{
// Get data from CClient
qint16 header;
m_socketSteam >> header;
switch (header)
{
case EHEADERTYPES::CS_LOGIN: clientLogin(); break;
default:break;
}
}
static
int connectToRemoteiRODS(
char* inStr,
rcComm_t** rcComm ) {
rErrMsg_t errMsg;
/*inStr of form: //irods:host[:port][:user[@zone][:pass]]/remotePath
if port is not given default port 1247 is used
if user@zone is not given ANONYMOUS_USER is used
if pass is not given ANONYMOUS_USER is used
*/
const std::string input( inStr );
boost::smatch matches;
boost::regex expression( "irods:([^:/]+)(:([0-9]+))?" // irods:host[:port]
"(:([^:/@]+)(@([^:/]+))?(:([^/]+))?)?" // [:user[@zone][:pass]]
"/(.*)" ); // /remotePath
try {
const bool matched = boost::regex_match( input, matches, expression );
if ( !matched ) {
return USER_INPUT_FORMAT_ERR;
}
std::string host = matches.str( 1 );
int port = 1247;
if ( !matches.str( 3 ).empty() ) {
port = boost::lexical_cast<int>( matches.str( 3 ) );
}
std::string user( ANONYMOUS_USER );
if ( !matches.str( 5 ).empty() ) {
user = matches.str( 5 );
}
std::string zone = matches.str( 7 );
printf( "MM: host=%s,port=%i,user=%s\n", host.c_str(), port, user.c_str() );
*rcComm = rcConnect( host.c_str(), port, user.c_str(), zone.c_str(), 0, &errMsg );
if ( *rcComm == NULL ) {
return REMOTE_IRODS_CONNECT_ERR;
}
int status = clientLogin( *rcComm );
if ( status != 0 ) {
rcDisconnect( *rcComm );
}
return status;
}
catch ( const boost::bad_lexical_cast& ) {
return INVALID_LEXICAL_CAST;
}
catch ( const boost::exception& ) {
return SYS_INTERNAL_ERR;
}
}
int connectToX() {
int status;
int sleepSec = 1;
if ( conn != NULL ) {
return 0;
}
status = getRodsEnv( &myRodsEnv );
if ( status < 0 ) {
fprintf( stderr, "getRodsEnv error, status = %d\n", status );
exit( 1 );
}
while ( conn == NULL ) {
conn = rcConnectXmsg( &myRodsEnv, &errMsg );
if ( conn == NULL ) {
fprintf( stderr, "rcConnectXmsg error...Will try again\n" );
sleep( sleepSec );
sleepSec = 2 * sleepSec;
if ( sleepSec > 10 ) {
sleepSec = 10;
}
continue;
}
status = clientLogin( conn );
if ( status != 0 ) {
rcDisconnect( conn );
conn = NULL;
fprintf( stderr, "clientLogin error...Will try again\n" );
sleep( sleepSec );
sleepSec = 2 * sleepSec;
if ( sleepSec > 10 ) {
sleepSec = 10;
}
continue;
}
}
return 0;
}
void connection_pool::create_connection(int _index,
std::function<void()> _on_connect_error,
std::function<void()> _on_login_error)
{
auto& ctx = conn_ctxs_[_index];
ctx.creation_time = std::time(nullptr);
ctx.conn.reset(rcConnect(host_.c_str(),
port_,
username_.c_str(),
zone_.c_str(),
NO_RECONN,
&ctx.error));
if (!ctx.conn) {
_on_connect_error();
return;
}
if (clientLogin(ctx.conn.get()) != 0) {
_on_login_error();
}
}
int
sendIxmsg( rcComm_t **inconn, sendXmsgInp_t *sendXmsgInp){
int status;
int sleepSec = 1;
rcComm_t *conn;
conn = *inconn;
while (connectFlag == 0) {
conn = rcConnectXmsg (&myRodsEnv, &errMsg);
if (conn == NULL) {
sleep(sleepSec);
sleepSec = 2 * sleepSec;
if (sleepSec > 10) sleepSec = 10;
continue;
}
status = clientLogin(conn);
if (status != 0) {
rcDisconnect(conn);
fprintf (stderr, "clientLogin error...Will try again\n");
sleep(sleepSec);
sleepSec = 2 * sleepSec;
if (sleepSec > 10) sleepSec = 10;
continue;
}
*inconn = conn;
connectFlag = 1;
}
status = rcSendXmsg (conn, sendXmsgInp);
/* rcDisconnect(conn); **/
if (status < 0) {
fprintf (stderr, "rsSendXmsg error. status = %d\n", status);
exit (9);
}
return(status);
}
int
main( int argc, char **argv ) {
signal( SIGPIPE, SIG_IGN );
int status;
rErrMsg_t errMsg;
rodsArguments_t myRodsArgs;
rodsEnv myEnv;
rodsLogLevel( LOG_ERROR );
status = parseCmdLineOpt( argc, argv, "hvVlz:Z", 1, &myRodsArgs );
if ( status ) {
printf( "Use -h for help.\n" );
exit( 1 );
}
if ( myRodsArgs.help == True ) {
usage();
exit( 0 );
}
if ( myRodsArgs.zone == True ) {
strncpy( zoneArgument, myRodsArgs.zoneName, MAX_NAME_LEN );
}
status = getRodsEnv( &myEnv );
if ( status < 0 ) {
rodsLog( LOG_ERROR, "main: getRodsEnv error. status = %d",
status );
exit( 1 );
}
// =-=-=-=-=-=-=-
// initialize pluggable api table
irods::pack_entry_table& pk_tbl = irods::get_pack_table();
irods::api_entry_table& api_tbl = irods::get_client_api_table();
init_api_table( api_tbl, pk_tbl );
Conn = rcConnect( myEnv.rodsHost, myEnv.rodsPort, myEnv.rodsUserName,
myEnv.rodsZone, 0, &errMsg );
if ( Conn == NULL ) {
char *mySubName = NULL;
const char *myName = rodsErrorName( errMsg.status, &mySubName );
rodsLog( LOG_ERROR, "rcConnect failure %s (%s) (%d) %s",
myName,
mySubName,
errMsg.status,
errMsg.msg );
free( mySubName );
exit( 2 );
}
status = clientLogin( Conn );
if ( status != 0 ) {
exit( 3 );
}
// tree view
if ( myRodsArgs.longOption != True ) {
if ( myRodsArgs.ascii == True ) { // character set for printing tree
gfx_mode = 0;
}
status = showRescTree( argv[myRodsArgs.optind] );
}
else { // regular view
status = showResc( argv[myRodsArgs.optind], myRodsArgs.longOption );
}
printErrorStack( Conn->rError );
rcDisconnect( Conn );
/* Exit 0 if one or more items were displayed */
if ( status >= 0 ) {
return 0;
}
else {
return status;
}
}
int
main( int argc, char **argv ) {
int status, i, j;
rErrMsg_t errMsg;
rodsArguments_t myRodsArgs;
char *mySubName;
char *myName;
int argOffset;
int maxCmdTokens = 20;
char *cmdToken[20];
int keepGoing;
int firstTime;
rodsLogLevel( LOG_ERROR );
status = parseCmdLineOpt( argc, argv, "vVhgrcGRCdulz:", 0, &myRodsArgs );
if ( status ) {
printf( "Use -h for help.\n" );
exit( 1 );
}
if ( myRodsArgs.help == True ) {
usage( "" );
exit( 0 );
}
if ( myRodsArgs.zone == True ) {
strncpy( zoneArgument, myRodsArgs.zoneName, MAX_NAME_LEN );
}
if ( myRodsArgs.longOption ) {
longMode = 1;
}
argOffset = myRodsArgs.optind;
if ( argOffset > 1 ) {
if ( argOffset > 2 ) {
if ( *argv[1] == '-' && *( argv[1] + 1 ) == 'z' ) {
if ( *( argv[1] + 2 ) == '\0' ) {
argOffset = 3; /* skip -z zone */
}
else {
argOffset = 2; /* skip -zzone */
}
}
else {
argOffset = 1; /* Ignore the parseCmdLineOpt parsing
as -d etc handled below*/
}
}
else {
argOffset = 1; /* Ignore the parseCmdLineOpt parsing
as -d etc handled below*/
}
}
status = getRodsEnv( &myEnv );
if ( status < 0 ) {
rodsLog( LOG_ERROR, "main: getRodsEnv error. status = %d",
status );
exit( 1 );
}
strncpy( cwd, myEnv.rodsCwd, BIG_STR );
if ( strlen( cwd ) == 0 ) {
strcpy( cwd, "/" );
}
for ( i = 0; i < maxCmdTokens; i++ ) {
cmdToken[i] = "";
}
j = 0;
for ( i = argOffset; i < argc; i++ ) {
cmdToken[j++] = argv[i];
}
#if defined(linux_platform)
/*
imeta cp -d TestFile1 -d TestFile3
comes in as: -d -d cp TestFile1 TestFile3
so switch it to: cp -d -d TestFile1 TestFile3
*/
if ( cmdToken[0] != NULL && *cmdToken[0] == '-' ) {
/* args were toggled, switch them back */
if ( cmdToken[1] != NULL && *cmdToken[1] == '-' ) {
cmdToken[0] = argv[argOffset + 2];
cmdToken[1] = argv[argOffset];
cmdToken[2] = argv[argOffset + 1];
}
else {
cmdToken[0] = argv[argOffset + 1];
cmdToken[1] = argv[argOffset];
}
}
#else
/* tested on Solaris, not sure other than Linux/Solaris */
/*
imeta cp -d TestFile1 -d TestFile3
comes in as: cp -d TestFile1 -d TestFile3
so switch it to: cp -d -d TestFile1 TestFile3
*/
if ( cmdToken[0] != NULL && cmdToken[1] != NULL && *cmdToken[1] == '-' &&
cmdToken[2] != NULL && cmdToken[3] != NULL && *cmdToken[3] == '-' ) {
/* two args */
cmdToken[2] = argv[argOffset + 3];
cmdToken[3] = argv[argOffset + 2];
}
#endif
if ( strcmp( cmdToken[0], "help" ) == 0 ||
strcmp( cmdToken[0], "h" ) == 0 ) {
usage( cmdToken[1] );
exit( 0 );
}
if ( strcmp( cmdToken[0], "spass" ) == 0 ) {
char scrambled[MAX_PASSWORD_LEN + 100];
if ( strlen( cmdToken[1] ) > MAX_PASSWORD_LEN - 2 ) {
printf( "Password exceeds maximum length\n" );
}
else {
obfEncodeByKey( cmdToken[1], cmdToken[2], scrambled );
printf( "Scrambled form is:%s\n", scrambled );
}
exit( 0 );
}
// =-=-=-=-=-=-=-
// initialize pluggable api table
irods::api_entry_table& api_tbl = irods::get_client_api_table();
irods::pack_entry_table& pk_tbl = irods::get_pack_table();
init_api_table( api_tbl, pk_tbl );
Conn = rcConnect( myEnv.rodsHost, myEnv.rodsPort, myEnv.rodsUserName,
myEnv.rodsZone, 0, &errMsg );
if ( Conn == NULL ) {
myName = rodsErrorName( errMsg.status, &mySubName );
rodsLog( LOG_ERROR, "rcConnect failure %s (%s) (%d) %s",
myName,
mySubName,
errMsg.status,
errMsg.msg );
exit( 2 );
}
status = clientLogin( Conn );
if ( status != 0 ) {
if ( !debug ) {
exit( 3 );
}
}
keepGoing = 1;
firstTime = 1;
while ( keepGoing ) {
int status;
status = doCommand( cmdToken );
if ( status == -1 ) {
keepGoing = 0;
}
if ( firstTime ) {
if ( status == 0 ) {
keepGoing = 0;
}
if ( status == -2 ) {
keepGoing = 0;
lastCommandStatus = -1;
}
firstTime = 0;
}
if ( keepGoing ) {
getInput( cmdToken, maxCmdTokens );
}
}
printErrorStack( Conn->rError );
rcDisconnect( Conn );
if ( lastCommandStatus != 0 ) {
exit( 4 );
}
exit( 0 );
}
int
main( int argc, char **argv ) {
signal( SIGPIPE, SIG_IGN );
int status;
rodsEnv myEnv;
rErrMsg_t errMsg;
rcComm_t *conn;
rodsArguments_t myRodsArgs;
char *optStr;
int noDistinctFlag = 0;
int upperCaseFlag = 0;
optStr = "hz:Z";
status = parseCmdLineOpt( argc, argv, optStr, 1, &myRodsArgs );
if ( myRodsArgs.optind < argc ) {
if ( !strcmp( argv[myRodsArgs.optind], "no-distinct" ) ) {
noDistinctFlag = 1;
myRodsArgs.optind++;
}
}
if ( myRodsArgs.optind < argc ) {
if ( strncmp( argv[myRodsArgs.optind], "upper", 5 ) == 0 ) {
upperCaseFlag = 1;
myRodsArgs.optind++;
}
}
if ( status < 0 ) {
printf( "Use -h for help\n" );
exit( 1 );
}
if ( myRodsArgs.help == True ) {
usage();
exit( 0 );
}
if ( myRodsArgs.optind == argc ) {
printf( "StringCondition needed\n" );
usage();
exit( 0 );
}
status = getRodsEnv( &myEnv );
if ( status < 0 ) {
rodsLogError( LOG_ERROR, status, "main: getRodsEnv error. " );
exit( 1 );
}
if ( myRodsArgs.optind == 1 ) {
if ( !strncmp( argv[argc - 1], "attrs", 5 ) ) {
showAttrNames();
exit( 0 );
}
}
// =-=-=-=-=-=-=-
// initialize pluggable api table
irods::api_entry_table& api_tbl = irods::get_client_api_table();
irods::pack_entry_table& pk_tbl = irods::get_pack_table();
init_api_table( api_tbl, pk_tbl );
conn = rcConnect( myEnv.rodsHost, myEnv.rodsPort, myEnv.rodsUserName,
myEnv.rodsZone, 0, &errMsg );
if ( conn == NULL ) {
exit( 2 );
}
status = clientLogin( conn );
if ( status != 0 ) {
exit( 3 );
}
if ( myRodsArgs.sql ) {
status = execAndShowSpecificQuery( conn, argv[myRodsArgs.optind],
argv,
myRodsArgs.optind + 1,
myRodsArgs.noPage,
myRodsArgs.zoneName );
rcDisconnect( conn );
if ( status < 0 ) {
rodsLogError( LOG_ERROR, status, "iquest Error: specificQuery (sql-query) failed" );
exit( 4 );
}
else {
exit( 0 );
}
}
if ( myRodsArgs.optind == ( argc - 3 ) ) {
status = queryAndShowStrCond( conn, argv[argc - 3],
argv[argc - 2], argv[argc - 1],
noDistinctFlag, upperCaseFlag,
myRodsArgs.zoneName,
myRodsArgs.noPage );
}
else if ( myRodsArgs.optind == ( argc - 2 ) ) {
status = queryAndShowStrCond( conn, NULL, argv[argc - 2], argv[argc - 1],
noDistinctFlag, upperCaseFlag,
myRodsArgs.zoneName,
myRodsArgs.noPage );
}
else {
status = queryAndShowStrCond( conn, NULL, NULL, argv[argc - 1],
noDistinctFlag, upperCaseFlag,
myRodsArgs.zoneName,
myRodsArgs.noPage );
}
rcDisconnect( conn );
if ( status < 0 ) {
if ( status == CAT_NO_ROWS_FOUND ) {
printf( "CAT_NO_ROWS_FOUND: Nothing was found matching your query\n" );
exit( 0 );
}
else {
rodsLogError( LOG_ERROR, status, "iquest Error: queryAndShowStrCond failed" );
exit( 4 );
}
}
else {
exit( 0 );
}
}
int
main( int argc, char **argv ) {
signal( SIGPIPE, SIG_IGN );
int status;
rodsEnv myEnv;
rErrMsg_t errMsg;
rcComm_t *conn;
rodsArguments_t myRodsArgs;
char *optStr;
rodsPathInp_t rodsPathInp;
optStr = "hKfarR:vVn:Z";
status = parseCmdLineOpt( argc, argv, optStr, 1, &myRodsArgs );
if ( status < 0 ) {
printf( "Use -h for help.\n" );
exit( 1 );
}
if ( myRodsArgs.help == True ) {
usage();
exit( 0 );
}
if ( argc - optind <= 0 ) {
rodsLog( LOG_ERROR, "ichksum: no input" );
printf( "Use -h for help.\n" );
exit( 2 );
}
status = getRodsEnv( &myEnv );
if ( status < 0 ) {
rodsLogError( LOG_ERROR, status, "main: getRodsEnv error. " );
exit( 1 );
}
status = parseCmdLinePath( argc, argv, optind, &myEnv,
UNKNOWN_OBJ_T, NO_INPUT_T, 0, &rodsPathInp );
if ( status < 0 ) {
rodsLogError( LOG_ERROR, status, "main: parseCmdLinePath error. " );
printf( "Use -h for help.\n" );
exit( 1 );
}
// =-=-=-=-=-=-=-
// initialize pluggable api table
irods::api_entry_table& api_tbl = irods::get_client_api_table();
irods::pack_entry_table& pk_tbl = irods::get_pack_table();
init_api_table( api_tbl, pk_tbl );
conn = rcConnect( myEnv.rodsHost, myEnv.rodsPort, myEnv.rodsUserName,
myEnv.rodsZone, 1, &errMsg );
if ( conn == NULL ) {
exit( 2 );
}
status = clientLogin( conn );
if ( status != 0 ) {
rcDisconnect( conn );
exit( 7 );
}
status = chksumUtil( conn, &myEnv, &myRodsArgs, &rodsPathInp );
printErrorStack( conn->rError );
rcDisconnect( conn );
if ( status < 0 ) {
exit( 3 );
}
else {
exit( 0 );
}
}
int
main(int argc, char **argv) {
int status;
rodsEnv myEnv;
rErrMsg_t errMsg;
rcComm_t *conn;
rodsArguments_t myRodsArgs;
char *optStr;
execCmd_t execCmd;
execCmdOut_t *execCmdOut = NULL;
int nArg;
char *tmpPtr;
optStr = "hvH:p:P:";
status = parseCmdLineOpt (argc, argv, optStr, 1, &myRodsArgs);
if (status < 0) {
printf("Use -h for help.\n");
exit (1);
}
if (myRodsArgs.help==True) {
usage();
exit(0);
}
nArg = argc - optind;
if (nArg <= 0 || nArg > 1) {
rodsLog (LOG_ERROR, "iexecmd: no input or too many input");
printf("Use -h for help.\n");
exit (2);
}
if (myRodsArgs.physicalPath == True && myRodsArgs.logicalPath == True) {
rodsLog (LOG_ERROR,
"iexecmd: -p and -P options cannot be used together");
exit (3);
}
memset (&execCmd, 0, sizeof (execCmd));
if ((tmpPtr = strchr (argv[optind], ' ')) != NULL &&
tmpPtr != argv[optind]) {
/* have argv in the command */
*tmpPtr = '\0';
rstrcpy (execCmd.cmd, argv[optind], LONG_NAME_LEN);
tmpPtr ++;
rstrcpy (execCmd.cmdArgv, tmpPtr, HUGE_NAME_LEN);
} else {
rstrcpy (execCmd.cmd, argv[optind], LONG_NAME_LEN);
}
if (myRodsArgs.hostAddr == True) {
rstrcpy (execCmd.execAddr, myRodsArgs.hostAddrString, LONG_NAME_LEN);
}
if (myRodsArgs.physicalPath == True) {
rstrcpy (execCmd.hintPath, myRodsArgs.physicalPathString,
LONG_NAME_LEN);
execCmd.addPathToArgv = 0;
} else if (myRodsArgs.logicalPath == True) {
rstrcpy (execCmd.hintPath, myRodsArgs.logicalPathString,
LONG_NAME_LEN);
execCmd.addPathToArgv = 1;
}
addKeyVal (&execCmd.condInput, STREAM_STDOUT_KW, "");
status = getRodsEnv (&myEnv);
if (status < 0) {
rodsLogError (LOG_ERROR, status, "main: getRodsEnv error. ");
exit (1);
}
conn = rcConnect (myEnv.rodsHost, myEnv.rodsPort, myEnv.rodsUserName,
myEnv.rodsZone, 0, &errMsg);
if (conn == NULL) {
exit (2);
}
status = clientLogin(conn);
if (status != 0) {
rcDisconnect(conn);
exit (7);
}
status = rcExecCmd (conn, &execCmd, &execCmdOut);
if (status == SYS_UNMATCHED_API_NUM) {
/* try older version */
execCmd241_t execCmd241Inp;
rstrcpy (execCmd241Inp.cmd, execCmd.cmd, LONG_NAME_LEN);
rstrcpy (execCmd241Inp.cmdArgv, execCmd.cmdArgv, HUGE_NAME_LEN);
rstrcpy (execCmd241Inp.execAddr, execCmd.execAddr, LONG_NAME_LEN);
rstrcpy (execCmd241Inp.hintPath, execCmd.hintPath, LONG_NAME_LEN);
execCmd241Inp.addPathToArgv = execCmd.addPathToArgv;
bzero (&execCmd241Inp.condInput, sizeof (keyValPair_t));
status = rcExecCmd241 (conn, &execCmd241Inp, &execCmdOut);
}
if (status < 0) {
rodsLogError (LOG_ERROR, status, "rcExecCmd error. ");
printErrorStack (conn->rError);
if (execCmdOut != NULL && execCmdOut->stderrBuf.buf != NULL) {
fprintf (stderr, "%s", (char *) execCmdOut->stderrBuf.buf);
}
rcDisconnect(conn);
exit (4);
}
if (myRodsArgs.verbose == True) {
printf ("rcExecCmd completed successfully. Output \n\n");
}
if (execCmdOut != NULL) {
int i;
char *tmpPtr;
fileReadInp_t streamReadInp;
fileCloseInp_t streamCloseInp;
bytesBuf_t *streamReadOutBBuf;
int bytesRead;
if (execCmdOut->stdoutBuf.buf != NULL) {
tmpPtr = (char*)execCmdOut->stdoutBuf.buf;
for (i = 0; i < execCmdOut->stdoutBuf.len; i++) {
fputc ((int)(*tmpPtr), stdout);
tmpPtr++;
}
}
if (execCmdOut->stderrBuf.buf != NULL) {
tmpPtr = (char*)execCmdOut->stderrBuf.buf;
for (i = 0; i < execCmdOut->stderrBuf.len; i++) {
fputc ((int)(*tmpPtr), stderr);
tmpPtr++;
}
}
if (execCmdOut->status > 0) {
/* (execCmdOut->status is a stream descriptor */
bzero (&streamReadInp, sizeof (streamReadInp));
streamReadOutBBuf = &execCmdOut->stdoutBuf;
if (streamReadOutBBuf->len < MAX_SZ_FOR_EXECMD_BUF) {
if (streamReadOutBBuf->buf != NULL) {
free (streamReadOutBBuf->buf);
}
streamReadOutBBuf->buf = malloc (MAX_SZ_FOR_EXECMD_BUF);
}
streamReadOutBBuf->len = streamReadInp.len = MAX_SZ_FOR_EXECMD_BUF;
streamReadInp.fileInx = execCmdOut->status;
while ((bytesRead = rcStreamRead (conn, &streamReadInp,
streamReadOutBBuf)) > 0) {
tmpPtr = (char*)streamReadOutBBuf->buf;
for (i = 0; i < bytesRead; i++) {
fputc ((int)(*tmpPtr), stdout);
tmpPtr++;
}
}
streamCloseInp.fileInx = execCmdOut->status;
rcStreamClose (conn, &streamCloseInp);
}
}
rcDisconnect(conn);
exit(0);
}
int
main(int argc, char **argv) {
int status, status2;
rErrMsg_t errMsg;
rodsArguments_t myRodsArgs;
char *mySubName;
char *myName;
rodsEnv myEnv;
rodsLogLevel(LOG_ERROR);
status = parseCmdLineOpt (argc, argv, "AhvVlz:", 0, &myRodsArgs);
if (status) {
printf("Use -h for help.\n");
exit(1);
}
if (myRodsArgs.help==True) {
usage();
exit(0);
}
if (myRodsArgs.zone==True) {
strncpy(zoneArgument, myRodsArgs.zoneName, MAX_NAME_LEN);
}
status = getRodsEnv (&myEnv);
if (status < 0) {
rodsLog (LOG_ERROR, "main: getRodsEnv error. status = %d",
status);
exit (1);
}
Conn = rcConnect (myEnv.rodsHost, myEnv.rodsPort, myEnv.rodsUserName,
myEnv.rodsZone, 0, &errMsg);
if (Conn == NULL) {
myName = rodsErrorName(errMsg.status, &mySubName);
rodsLog(LOG_ERROR, "rcConnect failure %s (%s) (%d) %s",
myName,
mySubName,
errMsg.status,
errMsg.msg);
exit (2);
}
status = clientLogin(Conn);
if (status != 0) {
exit (3);
}
status2=0;
if (myRodsArgs.optind == argc) { /* no resource name specified */
status = showResc(argv[myRodsArgs.optind], myRodsArgs.longOption);
status2 = showRescGroups(myRodsArgs.longOption);
}
else {
if (myRodsArgs.accessControl == True) {
showRescAcl(argv[myRodsArgs.optind]);
}
else {
status = showOneRescGroup(argv[myRodsArgs.optind],
myRodsArgs.longOption);
if (status==0) {
status2 = showResc(argv[myRodsArgs.optind], myRodsArgs.longOption);
if (status2==0) {
/* Only print this if both fail */
printf("Resource-group %s does not exist.\n",
argv[myRodsArgs.optind]);
}
}
}
}
printErrorStack(Conn->rError);
rcDisconnect(Conn);
/* Exit 0 if one or more items were displayed */
if (status > 0) exit(0);
if (status2 > 0) exit(0);
exit(4);
}
int
main( int argc, char **argv ) {
signal( SIGPIPE, SIG_IGN );
int status;
rodsEnv myEnv;
rErrMsg_t errMsg;
rcComm_t *conn;
rodsArguments_t myRodsArgs;
char *optStr, buffer[HUGE_NAME_LEN];
rodsPathInp_t rodsPathInp;
objType_t srcType, destType;
int nArgv;
int i;
optStr = "ahKlN:rR:svVZ";
status = parseCmdLineOpt( argc, argv, optStr, 1, &myRodsArgs );
if ( status < 0 ) {
printf( "use -h for help.\n" );
exit( 1 );
}
if ( myRodsArgs.help == True ) {
usage();
exit( 0 );
}
status = getRodsEnv( &myEnv );
if ( status < 0 ) {
rodsLogError( LOG_ERROR, status, "main: getRodsEnv error. " );
exit( 1 );
}
nArgv = argc - optind;
if ( nArgv < 2 ) { /* must have at least 2 input */
usage();
exit( 1 );
}
for ( i = 2; i <= nArgv; i++ ) {
if ( strcmp( argv[argc - i], "i:" ) == 0 ) {
srcType = UNKNOWN_OBJ_T;
strcpy( argv[argc - i], "." );
}
else if ( strncmp( argv[argc - i], "i:", 2 ) == 0 ) {
srcType = UNKNOWN_OBJ_T;
snprintf( buffer, HUGE_NAME_LEN, "%s", argv[argc - i] + 2 );
argv[argc - i] = strdup( buffer );
}
else {
srcType = UNKNOWN_FILE_T;
}
}
if ( strcmp( argv[argc - 1], "i:" ) == 0 ) {
destType = UNKNOWN_OBJ_T;
strcpy( argv[argc - 1], "." );
}
else if ( strncmp( argv[argc - 1], "i:", 2 ) == 0 ) {
destType = UNKNOWN_OBJ_T;
snprintf( buffer, HUGE_NAME_LEN, "%s", argv[argc - 1] + 2 );
argv[argc - 1] = strdup( argv[argc - 1] + 2 );
}
else {
destType = UNKNOWN_FILE_T;
}
if ( srcType == UNKNOWN_FILE_T && destType == UNKNOWN_FILE_T ) {
rodsLog( LOG_ERROR,
"Both source and destination cannot be local file type" );
exit( 1 );
}
status = parseCmdLinePath( argc, argv, optind, &myEnv,
srcType, destType, 0, &rodsPathInp );
if ( status < 0 ) {
rodsLogError( LOG_ERROR, status, "main: parseCmdLinePath error. " );
printf( "use -h for help.\n" );
exit( 1 );
}
// =-=-=-=-=-=-=-
// initialize pluggable api table
irods::api_entry_table& api_tbl = irods::get_client_api_table();
irods::pack_entry_table& pk_tbl = irods::get_pack_table();
init_api_table( api_tbl, pk_tbl );
conn = rcConnect( myEnv.rodsHost, myEnv.rodsPort, myEnv.rodsUserName,
myEnv.rodsZone, 1, &errMsg );
if ( conn == NULL ) {
exit( 2 );
}
status = clientLogin( conn );
if ( status != 0 ) {
rcDisconnect( conn );
exit( 7 );
}
status = rsyncUtil( conn, &myEnv, &myRodsArgs, &rodsPathInp );
printErrorStack( conn->rError );
rcDisconnect( conn );
if ( status < 0 ) {
exit( 3 );
}
else {
exit( 0 );
}
}
int
main( int argc, char **argv ) {
int status;
rErrMsg_t errMsg;
rodsArguments_t myRodsArgs;
int argOffset;
rodsLogLevel( LOG_ERROR );
status = parseCmdLineOpt( argc, argv, "hvV", 0, &myRodsArgs );
if ( status ) {
printf( "Use -h for help\n" );
exit( 1 );
}
if ( myRodsArgs.help == True ) {
usage();
exit( 0 );
}
argOffset = myRodsArgs.optind;
status = getRodsEnv( &myEnv );
if ( status < 0 ) {
rodsLog( LOG_ERROR, "main: getRodsEnv error. status = %d",
status );
exit( 1 );
}
if ( argOffset != argc - 3 ) {
usage();
exit( -1 );
}
// =-=-=-=-=-=-=-
// initialize pluggable api table
irods::api_entry_table& api_tbl = irods::get_client_api_table();
irods::pack_entry_table& pk_tbl = irods::get_pack_table();
init_api_table( api_tbl, pk_tbl );
Conn = rcConnect( myEnv.rodsHost, myEnv.rodsPort, myEnv.rodsUserName,
myEnv.rodsZone, 0, &errMsg );
if ( Conn == NULL ) {
exit( 2 );
}
status = clientLogin( Conn );
if ( status != 0 ) {
printError( Conn, status, "clientLogin" );
if ( !debug ) {
exit( 3 );
}
}
status = modDelayedRule( argv[argOffset], argv[argOffset + 1],
argv[argOffset + 2] );
printErrorStack( Conn->rError );
rcDisconnect( Conn );
if ( status != 0 ) {
exit( 4 );
}
exit( 0 );
}
int icommands::irm(int argc, char **argv) {
int status;
rodsEnv myEnv;
rErrMsg_t errMsg;
rcComm_t *conn;
rodsArguments_t myRodsArgs;
char *optStr;
rodsPathInp_t rodsPathInp;
optStr = "hfruUvVfn:";
status = parseCmdLineOpt (argc, argv, optStr, 0, &myRodsArgs);
if (status < 0) {
printf("Use -h for help.\n");
exit (1);
}
if (myRodsArgs.help==True) {
// usage();
exit(0);
}
if (argc - optind <= 0) {
rodsLog (LOG_ERROR, "irm: no input");
printf("Use -h for help.\n");
exit (2);
}
status = getRodsEnv (&myEnv);
if (status < 0) {
rodsLogError (LOG_ERROR, status, "main: getRodsEnv error. ");
exit (1);
}
status = parseCmdLinePath (argc, argv, optind, &myEnv,
UNKNOWN_OBJ_T, NO_INPUT_T, 0, &rodsPathInp);
if (status < 0) {
rodsLogError (LOG_ERROR, status, "main: parseCmdLinePath error. ");
printf("Use -h for help.\n");
exit (1);
}
conn = rcConnect (myEnv.rodsHost, myEnv.rodsPort, myEnv.rodsUserName,
myEnv.rodsZone, 1, &errMsg);
if (conn == NULL) {
exit (2);
}
status = clientLogin(conn);
if (status != 0) {
rcDisconnect(conn);
exit (7);
}
status = rmUtil (conn, &myEnv, &myRodsArgs, &rodsPathInp);
rcDisconnect(conn);
if (status < 0) {
exit (3);
}
else {
// exit(0);
return 0;
}
}
void GoogleDocumentService::handleNetworkData(QNetworkReply *networkReply)
{
if (!networkReply->error()) {
if (!loggedin) {
QString text(networkReply->readAll());
text = text.right(text.length() - text.indexOf("Auth=") - 5);
authToken = QString("GoogleLogin auth=") + text.left(text.indexOf("\n"));
if(authToken.length() > 20) {
if(!haveDocAuthToken) {
docAuthToken = authToken;
haveDocAuthToken = true;
qDebug() << "Received Doc token = " << docAuthToken;
clientLogin(this->username, this->password);
return;
}
spreadAuthToken = authToken;
authToken = "";
loggedin = true;
qDebug() << "Received Spreadsheet token = " << spreadAuthToken;
listDocuments();
emit userAuthenticated(loggedin, "");
}
}
else if (waitingForDoc) {
QByteArray data = networkReply->readAll();
QFile file(QDir::tempPath() + QLatin1Char('/') + documentList->currentDocument());
file.open(QIODevice::ReadWrite);
file.write(data);
file.close();
qDebug() << "Received Document!!!!! " << file.fileName();
emit receivedDocument(file.fileName());
waitingForDoc = false;
showDocumentListWindow(false);
}
else {
QByteArray bytAry = networkReply->readAll();
// qDebug() << bytAry;
// xmlInput.setData(networkReply->readAll());
xmlInput.setData(bytAry);
qDebug() << "Part received.........";
if (newInformation) {
emit progressUpdate("Parsing document list...");
newInformation = xmlReader.parse(&xmlInput, true);
qDebug() << "New Information = " << newInformation;
// newInformation = false;
getDocument();
}
}
} else {
QString errorString(networkReply->readAll());
qDebug() << "Error occurred !!!! " << errorString;
errorString = errorString.right(errorString.length() - errorString.indexOf("Error=") - 6);
if (!loggedin) {
emit userAuthenticated(loggedin, errorString);
} else {
QMessageBox msgBox(QMessageBox::Information, i18n("Online Document Services"),
"Error occurred !!!! " + errorString);
msgBox.exec();
}
}
}
int
main(int argc, char **argv)
{
int status;
rodsArguments_t myRodsArgs;
rodsEnv myEnv;
int i, j, didOne;
char objPath[MAX_NAME_LEN];
int maxCmdTokens=20;
char *cmdToken[20];
int argOffset;
rcComm_t *Conn;
rErrMsg_t errMsg;
char *mySubName;
char *myName;
status = parseCmdLineOpt(argc, argv, "lvVh", 0, &myRodsArgs);
if (status) {
printf("Use -h for help\n");
exit(1);
}
if (myRodsArgs.help==True) {
usage("");
exit(0);
}
argOffset = myRodsArgs.optind;
status = getRodsEnv (&myEnv);
if (status < 0) {
rodsLog (LOG_ERROR, "main: getRodsEnv error. status = %d",
status);
exit (1);
}
strncpy(objPath,myEnv.rodsCwd,MAX_NAME_LEN);
for (i=0;i<maxCmdTokens;i++) {
cmdToken[i]="";
}
j=0;
for (i=argOffset;i<argc;i++) {
cmdToken[j++]=argv[i];
}
Conn = rcConnect (myEnv.rodsHost, myEnv.rodsPort, myEnv.rodsUserName,
myEnv.rodsZone, 0, &errMsg);
if (Conn == NULL) {
myName = rodsErrorName(errMsg.status, &mySubName);
rodsLog(LOG_ERROR, "rcConnect failure %s (%s) (%d) %s",
myName,
mySubName,
errMsg.status,
errMsg.msg);
exit (2);
}
status = clientLogin(Conn);
if (status != 0) {
rcDisconnect(Conn);
exit (3);
}
if (strcmp(cmdToken[0],"ldt")==0) {
if (*cmdToken[1]=='\0') {
cmdToken[1]=" "; /* just for subsequent checks below */
}
}
if (*cmdToken[1]=='\0') {
usage("");
exit(1);
}
if (*cmdToken[1]=='/') {
rstrcpy(objPath, cmdToken[1], MAX_NAME_LEN);
}
else {
rstrcat(objPath, "/", MAX_NAME_LEN);
rstrcat(objPath, cmdToken[1], MAX_NAME_LEN);
}
didOne=0;
if (strcmp(cmdToken[0],"ls")==0) {
int longOption;
if (myRodsArgs.longOption) longOption=1;
if (myRodsArgs.verbose) longOption=1;
doLs(Conn, objPath, longOption);
didOne=1;
}
if (strcmp(cmdToken[0],"ldt")==0) {
doListDataTypes(Conn);
didOne=1;
}
if (strcmp(cmdToken[0],"mod")==0) {
char theTime[TIME_LEN+20];
if (*cmdToken[2]=='\0') {
usage("");
exit(1);
}
if (strcmp(cmdToken[2],"datatype")==0) {
if (*cmdToken[3]=='\0') {
usage("");
exit(1);
}
status = doModDatatype(Conn, objPath, cmdToken[3]);
didOne=1;
}
else if (strcmp(cmdToken[2],"comment")==0) {
if (*cmdToken[3]=='\0') {
usage("");
exit(1);
}
if (*cmdToken[4]=='\0') {
status = doModComment(Conn, objPath, -1, cmdToken[3]);
}
else {
status = doModComment(Conn, objPath, atoi(cmdToken[3]), cmdToken[4]);
}
didOne=1;
}
else {
rstrcpy(theTime, cmdToken[2], TIME_LEN);
status=0;
if (*cmdToken[2]=='+') {
rstrcpy(theTime, cmdToken[2]+1, TIME_LEN); /* skip the + */
status = checkDateFormat(theTime); /* check and convert the time value */
getOffsetTimeStr(theTime, theTime); /* convert delta format to now + this*/
} else {
status = checkDateFormat(theTime); /* check and convert the time value */
}
if (status==0) {
status = doMod(Conn, objPath, theTime);
didOne=1;
}
else {
printf("Invalid time format input\n");
}
}
}
printErrorStack(Conn->rError);
rcDisconnect(Conn);
if (didOne==0) {
usage("");
exit(1);
}
exit(0);
}
static int
_download(const char *path, struct stat *stbufIn) {
int status;
rcComm_t *conn;
rodsPathInp_t rodsPathInp;
rErrMsg_t errMsg;
char preloadCachePath[MAX_NAME_LEN];
char preloadCacheWorkPath[MAX_NAME_LEN];
// set path for getUtil
status = _getCachePath(path, preloadCachePath);
if(status < 0) {
rodsLogError(LOG_ERROR, status, "_download: _getCachePath error.");
rodsLog (LOG_ERROR, "_download: failed to get cache path - %s", path);
return status;
}
status = _getCacheWorkPath(path, preloadCacheWorkPath);
if(status < 0) {
rodsLogError(LOG_ERROR, status, "_download: _getCacheWorkPath error.");
rodsLog (LOG_ERROR, "_download: failed to get cache work path - %s", path);
return status;
}
rodsLog (LOG_DEBUG, "_download: download %s to %s", path, preloadCachePath);
// set src path
memset( &rodsPathInp, 0, sizeof( rodsPathInp_t ) );
addSrcInPath( &rodsPathInp, (char*)path );
status = parseRodsPath (&rodsPathInp.srcPath[0], PreloadRodsEnv);
if(status < 0) {
rodsLogError(LOG_ERROR, status, "_download: parseRodsPath error.");
return status;
}
// set dest path
rodsPathInp.destPath = ( rodsPath_t* )malloc( sizeof( rodsPath_t ) );
memset( rodsPathInp.destPath, 0, sizeof( rodsPath_t ) );
rstrcpy( rodsPathInp.destPath->inPath, preloadCacheWorkPath, MAX_NAME_LEN );
status = parseLocalPath (rodsPathInp.destPath);
if(status < 0) {
rodsLogError(LOG_ERROR, status, "_download: parseLocalPath error.");
return status;
}
// Connect
conn = rcConnect (PreloadRodsEnv->rodsHost, PreloadRodsEnv->rodsPort, PreloadRodsEnv->rodsUserName, PreloadRodsEnv->rodsZone, RECONN_TIMEOUT, &errMsg);
if (conn == NULL) {
rodsLog (LOG_ERROR, "_download: error occurred while connecting to irods");
return -EPIPE;
}
// Login
if (strcmp (PreloadRodsEnv->rodsUserName, PUBLIC_USER_NAME) != 0) {
status = clientLogin(conn);
if (status != 0) {
rodsLogError(LOG_ERROR, status, "_download: ClientLogin error.");
rcDisconnect(conn);
return status;
}
}
// make dir
prepareDir(preloadCachePath);
// Preload
rodsLog (LOG_DEBUG, "_download: download %s", path);
status = getUtil (&conn, PreloadRodsEnv, PreloadRodsArgs, &rodsPathInp);
rodsLog (LOG_DEBUG, "_download: complete downloading %s", path);
// Disconnect
rcDisconnect(conn);
if(status < 0) {
rodsLogError(LOG_ERROR, status, "_download: getUtil error.");
return status;
}
// be careful when using Lock
LOCK(PreloadLock);
status = _completeDownload(preloadCacheWorkPath, preloadCachePath, stbufIn);
if(status < 0) {
rodsLogError(LOG_ERROR, status, "_download: _completeDownload error.");
UNLOCK(PreloadLock);
return status;
}
UNLOCK(PreloadLock);
return 0;
}
int
main(int argc, char **argv) {
int status, i, j;
rErrMsg_t errMsg;
rodsEnv myEnv;
rodsArguments_t myRodsArgs;
char *mySubName;
char *myName;
int argOffset;
int maxCmdTokens=20;
char *cmdToken[20];
int keepGoing;
int firstTime;
rodsLogLevel(LOG_ERROR);
status = parseCmdLineOpt (argc, argv, "vVh", 0, &myRodsArgs);
if (status) {
printf("Use -h for help.\n");
exit(1);
}
if (myRodsArgs.help==True) {
usage("");
exit(0);
}
argOffset = myRodsArgs.optind;
status = getRodsEnv (&myEnv);
if (status < 0) {
rodsLog (LOG_ERROR, "main: getRodsEnv error. status = %d",
status);
exit (1);
}
strncpy(myZone, myEnv.rodsZone, sizeof(myZone));
for (i=0;i<maxCmdTokens;i++) {
cmdToken[i]="";
}
j=0;
for (i=argOffset;i<argc;i++) {
cmdToken[j++]=argv[i];
}
if (strcmp(cmdToken[0],"help")==0 ||
strcmp(cmdToken[0],"h") == 0) {
usage(cmdToken[1]);
exit(0);
}
if (strcmp(cmdToken[0],"spass") ==0) {
char scrambled[MAX_PASSWORD_LEN+100];
if (strlen(cmdToken[1])>MAX_PASSWORD_LEN-2) {
printf("Password exceeds maximum length\n");
}
else {
obfEncodeByKey(cmdToken[1], cmdToken[2], scrambled);
printf("Scrambled form is:%s\n", scrambled);
}
exit(0);
}
Conn = rcConnect (myEnv.rodsHost, myEnv.rodsPort, myEnv.rodsUserName,
myEnv.rodsZone, 0, &errMsg);
if (Conn == NULL) {
myName = rodsErrorName(errMsg.status, &mySubName);
rodsLog(LOG_ERROR, "rcConnect failure %s (%s) (%d) %s",
myName,
mySubName,
errMsg.status,
errMsg.msg);
exit (2);
}
status = clientLogin(Conn);
if (status != 0) {
rcDisconnect(Conn);
exit (3);
}
keepGoing=1;
firstTime=1;
while (keepGoing) {
int status;
status=doCommand(cmdToken);
if (status==-1) keepGoing=0;
if (firstTime) {
if (status==0) keepGoing=0;
if (status==-2) {
keepGoing=0;
lastCommandStatus=-1;
}
firstTime=0;
}
if (keepGoing) {
getInput(cmdToken, maxCmdTokens);
}
}
printErrorStack(Conn->rError);
rcDisconnect(Conn);
if (lastCommandStatus != 0) exit(4);
exit(0);
}
int
main( int argc, char **argv ) {
rcComm_t *conn;
rodsEnv myEnv;
char *optStr;
rErrMsg_t errMsg;
int status;
rodsArguments_t rodsArgs;
int flag = 0;
int nativeAPI = 0;
optStr = "alL";
status = parseCmdLineOpt( argc, argv, optStr, 1, &rodsArgs );
if ( status < 0 ) {
printf( "parseCmdLineOpt error, status = %d.\n", status );
exit( 1 );
}
if ( argc - optind <= 0 ) {
rodsLog( LOG_ERROR, "no input" );
exit( 2 );
}
memset( &errMsg, 0, sizeof( rErrMsg_t ) );
status = getRodsEnv( &myEnv );
if ( status < 0 ) {
fprintf( stderr, "getRodsEnv error, status = %d\n", status );
exit( 1 );
}
conn = rcConnect( myEnv.rodsHost, myEnv.rodsPort, myEnv.rodsUserName,
myEnv.rodsZone, 1, &errMsg );
if ( conn == NULL ) {
fprintf( stderr, "rcConnect error\n" );
exit( 1 );
}
status = clientLogin( conn );
if ( status != 0 ) {
rcDisconnect( conn );
exit( 7 );
}
flag = setQueryFlag( &rodsArgs );
if ( rodsArgs.all == True ) {
nativeAPI = 1;
}
if ( nativeAPI == 1 ) {
status = printCollectionNat( conn, argv[optind], flag );
}
else {
status = printCollection( conn, argv[optind], flag );
}
rcDisconnect( conn );
exit( 0 );
}
int
main(int argc, char **argv) {
int status;
rodsEnv myEnv;
rErrMsg_t errMsg;
rcComm_t *conn;
rodsArguments_t myRodsArgs;
char *optStr;
rodsPathInp_t rodsPathInp;
int nArgv;
optStr = "bD:hR:cxD:fZ";
status = parseCmdLineOpt (argc, argv, optStr, 1, &myRodsArgs);
if (status < 0) {
printf("use -h for help.\n");
exit (1);
}
if (myRodsArgs.help==True) {
usage();
exit(0);
}
nArgv = argc - optind;
if (nArgv != 2) { /* must have 2 inputs */
usage ();
exit (1);
}
status = getRodsEnv (&myEnv);
if (status < 0) {
rodsLogError (LOG_ERROR, status, "main: getRodsEnv error. ");
exit (1);
}
status = parseCmdLinePath (argc, argv, optind, &myEnv,
UNKNOWN_OBJ_T, UNKNOWN_OBJ_T, 0, &rodsPathInp);
if (status < 0) {
rodsLogError (LOG_ERROR, status, "main: parseCmdLinePath error. ");
printf("use -h for help.\n");
exit (1);
}
conn = rcConnect (myEnv.rodsHost, myEnv.rodsPort, myEnv.rodsUserName,
myEnv.rodsZone, 1, &errMsg);
if (conn == NULL) {
exit (2);
}
status = clientLogin(conn);
if (status != 0) {
rcDisconnect(conn);
exit (7);
}
status = bunUtil (conn, &myEnv, &myRodsArgs, &rodsPathInp);
printErrorStack(conn->rError);
rcDisconnect(conn);
if (status < 0) {
exit (3);
} else {
exit(0);
}
}
int
main( int, char** ) {
signal( SIGPIPE, SIG_IGN );
rodsEnv myEnv;
int status = getRodsEnv( &myEnv );
if ( status < 0 ) {
rodsLogError( LOG_ERROR, status, "main: getRodsEnv error. " );
exit( 1 );
}
rErrMsg_t errMsg;
rcComm_t *conn;
conn = rcConnect(
myEnv.rodsHost,
myEnv.rodsPort,
myEnv.rodsUserName,
myEnv.rodsZone,
0, &errMsg );
if ( conn == NULL ) {
exit( 2 );
}
// =-=-=-=-=-=-=-
// initialize pluggable api table
irods::pack_entry_table& pk_tbl = irods::get_pack_table();
irods::api_entry_table& api_tbl = irods::get_client_api_table();
init_api_table( api_tbl, pk_tbl );
if ( strcmp( myEnv.rodsUserName, PUBLIC_USER_NAME ) != 0 ) {
status = clientLogin( conn );
if ( status != 0 ) {
rcDisconnect( conn );
exit( 7 );
}
}
helloInp_t inp;
memset( &inp, 0, sizeof( inp ) );
inp._this = 42;
strncpy( inp._that, "hello, world.", 64 );
void *tmp_out = NULL;
status = procApiRequest( conn, 1300, &inp, NULL,
&tmp_out, NULL );
if ( status < 0 ) {
printf( "\n\nERROR - failed to call our api\n\n\n" );
return 0;
}
else {
helloOut_t* out = static_cast<helloOut_t*>( tmp_out );
if ( out != NULL ) {
printf( "\n\nthis [%d] that [%s] other [%f]\n", out->_this, out->_that, out->_other._value );
}
else {
printf( "ERROR: the 'out' variable is null\n" );
}
}
rcDisconnect( conn );
}
static struct irods_server * connect_to_host( const char *hostport )
{
struct irods_server *server;
rcComm_t *conn;
rErrMsg_t errmsg;
char host[PFS_PATH_MAX];
int port;
if(!hostport[0]) {
errno = EACCES;
return 0;
}
if(!connect_cache) connect_cache = hash_table_create(0,0);
time_t current = time(0);
server = (struct irods_server*) hash_table_lookup(connect_cache,hostport);
if(server) {
if((current-server->lastused)>DISCONNECT_TIMEOUT) {
debug(D_IRODS,"discarding stale connection to %s",hostport);
rcDisconnect(server->conn);
free(server);
server = 0;
} else {
server->lastused = current;
return server;
}
}
if(!got_irods_env) {
rodsLogLevel(pfs_irods_debug_level);
if(getRodsEnv(&irods_env)<0) {
debug(D_IRODS,"couldn't load irods environment!");
return 0;
}
got_irods_env = 1;
}
debug(D_IRODS,"connecting to %s",hostport);
sscanf(hostport,"%[^:]:%d",host,&port);
conn = rcConnect(host,port,irods_env.rodsUserName,irods_env.rodsZone,1,&errmsg);
if(!conn) {
if(errno==EINPROGRESS) {
errno = ECONNREFUSED;
}
debug(D_IRODS,"couldn't connect: %s\n",strerror(errno));
return 0;
}
debug(D_IRODS,"logging in...");
if(clientLogin(conn)!=0) {
debug(D_IRODS,"unable to login as %s",irods_env.rodsUserName);
rcDisconnect(conn);
return 0;
}
server = malloc(sizeof(*server));
server->conn = conn;
server->lastused = current;
server->serial = irods_serial++;
hash_table_insert(connect_cache,hostport,server);
return server;
}
