irods  4.2.8
About: iRODS (the integrated Rule Oriented Data System) is a distributed data-management system for creating data grids, digital libraries, persistent archives, and real-time data systems.
  Fossies Dox: irods-4.2.8.tar.gz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

procApiRequest.cpp
Go to the documentation of this file.
1 
4 /* procApiRequest.c - process API request
5  */
6 
7 // =-=-=-=-=-=-=-
10 
11 #if defined(RODS_SERVER) || defined(RODS_CLERVER)
13 #endif // RODS_SERVER || RODS_CLERVER
14 
15 // =-=-=-=-=-=-=-
16 // irods includes
17 #include "procApiRequest.h"
18 #include "rcGlobalExtern.h"
19 #include "rcMisc.h"
20 #include "sockComm.h"
22 #include "sslSockComm.h"
24 
25 // =-=-=-=-=-=-=-
26 // stl includes
27 #include <iostream>
28 
29 // =-=-=-=-=-=-=-
30 // boost includes
31 #include <boost/shared_ptr.hpp>
32 
33 #include "irods_threads.hpp"
34 
35 
36 /* procApiRequest - This is the main function used by the client API
37  * function to issue API requests and receive output returned from
38  * the server.
39  * rcComm_t *conn - the client communication handle.
40  * int apiNumber - the API number of this call defined in apiNumber.h.
41  * void *inputStruct - pointer to the input struct of this API. If there
42  * is no input struct, a NULL should be entered
43  * bytesBuf_t *inputBsBBuf - pointer to the input byte stream. If there
44  * is no input byte stream, a NULL should be entered
45  * void **outStruct - Pointer to pointer to the output struct. The outStruct
46  * will be allocated by this function and the pointer to this struct is
47  * passed back to the caller through this pointer. If there
48  * is no output struct, a NULL should be entered
49  * bytesBuf_t *outBsBBuf - pointer to the output byte stream. If there
50  * is no output byte stream, a NULL should be entered
51  *
52  */
53 
54 int
55 procApiRequest( rcComm_t *conn, int apiNumber, void *inputStruct,
56  bytesBuf_t *inputBsBBuf, void **outStruct, bytesBuf_t *outBsBBuf ) {
57  int status = 0;
58  int apiInx = 0;
59 
60  if ( conn == NULL ) {
61  return USER__NULL_INPUT_ERR;
62  }
63 
64  freeRError( conn->rError );
65  conn->rError = NULL;
66 
67  apiInx = apiTableLookup( apiNumber );
68 
69  if ( apiInx < 0 ) {
71  "procApiRequest: apiTableLookup of apiNumber %d failed", apiNumber );
72  return apiInx;
73  }
74 
75  status = sendApiRequest( conn, apiInx, inputStruct, inputBsBBuf );
76  if ( status < 0 ) {
78  "procApiRequest: sendApiRequest failed. status = %d", status );
79  return status;
80  }
81 
82  conn->apiInx = apiInx;
83 
84  status = readAndProcApiReply( conn, apiInx, outStruct, outBsBBuf );
85  if ( status < 0 ) {
87  "procApiRequest: readAndProcApiReply failed. status = %d", status );
88  }
89 
90  return status;
91 }
92 
93 int
94 branchReadAndProcApiReply( rcComm_t *conn, int apiNumber,
95  void **outStruct, bytesBuf_t *outBsBBuf ) {
96  int status = 0;
97  int apiInx = 0;
98 
99  if ( conn == NULL ) {
100  return USER__NULL_INPUT_ERR;
101  }
102 
103  apiInx = apiTableLookup( apiNumber );
104  if ( apiInx < 0 ) {
106  "branchReadAndProcApiReply: apiTableLookup of apiNum %d failed",
107  apiNumber );
108  return apiInx;
109  }
110 
111  conn->apiInx = apiInx;
112 
113  status = readAndProcApiReply( conn, apiInx, outStruct, outBsBBuf );
114  if ( status < 0 ) {
116  "branchReadAndProcApiReply: readAndProcApiReply failed. status = %d",
117  status );
118  }
119  return status;
120 }
121 
122 int
123 sendApiRequest( rcComm_t *conn, int apiInx, void *inputStruct,
124  bytesBuf_t *inputBsBBuf ) {
125  int status = 0;
126  bytesBuf_t *inputStructBBuf = NULL;
127  bytesBuf_t *myInputStructBBuf = NULL;
128 
129  cliChkReconnAtSendStart( conn );
130 
132 
133  irods::api_entry_table::iterator itr = RcApiTable.find( apiInx );
134  if ( itr == RcApiTable.end() ) {
135  rodsLogError( LOG_ERROR, SYS_UNMATCHED_API_NUM, "API Entry not found at index %d", apiInx );
136  return SYS_UNMATCHED_API_NUM;
137  }
138 
139 
140  if ( RcApiTable[apiInx]->inPackInstruct != NULL ) {
141  if ( inputStruct == NULL ) {
142  cliChkReconnAtSendEnd( conn );
143  return USER_API_INPUT_ERR;
144  }
145  status = packStruct( ( void * ) inputStruct, &inputStructBBuf,
146  ( char* )RcApiTable[apiInx]->inPackInstruct, RodsPackTable, 0, conn->irodsProt );
147  if ( status < 0 ) {
149  "sendApiRequest: packStruct error, status = %d", status );
150  cliChkReconnAtSendEnd( conn );
151  return status;
152  }
153 
154  myInputStructBBuf = inputStructBBuf;
155  }
156  else {
157  myInputStructBBuf = NULL;
158  };
159 
160 
161  if ( RcApiTable[apiInx]->inBsFlag <= 0 ) {
162  inputBsBBuf = NULL;
163  }
164 
166  irods::error ret = irods::network_factory( conn, net_obj );
167  if ( !ret.ok() ) {
168  freeBBuf( inputStructBBuf );
169  irods::log( PASS( ret ) );
170  return ret.code();
171  }
172 
173  ret = sendRodsMsg(
174  net_obj,
176  myInputStructBBuf,
177  inputBsBBuf,
178  NULL,
179  RcApiTable[apiInx]->apiNumber,
180  conn->irodsProt );
181  if ( !ret.ok() ) {
182  irods::log( PASS( ret ) );
183  if ( conn->svrVersion != NULL &&
184  conn->svrVersion->reconnPort > 0 ) {
185  int status1;
186  int savedStatus = ret.code() ;
187  conn->thread_ctx->lock->lock();
188  status1 = cliSwitchConnect( conn );
190  "sendApiRequest: svrSwitchConnect. cliState = %d,agState=%d",
191  conn->clientState, conn->agentState );
192  conn->thread_ctx->lock->unlock();
193  if ( status1 > 0 ) {
194  /* should not be here */
196  "sendApiRequest: Switch connection and retry sendRodsMsg" );
197  ret = sendRodsMsg(
198  net_obj,
200  myInputStructBBuf,
201  inputBsBBuf,
202  NULL,
203  RcApiTable[apiInx]->apiNumber,
204  conn->irodsProt );
205  if ( !ret.ok() ) {
206  irods::log( PASS( ret ) );
207  }
208  else {
209  status = savedStatus;
210  }
211 
212  } // if status1 > 0
213 
214  } // if svrVersion != NULL ...
215 
216  }
217  else {
218  // =-=-=-=-=-=-=-
219  // be sure to pass along the return code from the
220  // plugin call
221  status = ret.code();
222 
223  }
224 
225  freeBBuf( inputStructBBuf );
226 
227  return status;
228 }
229 
230 int
231 readAndProcApiReply( rcComm_t *conn, int apiInx, void **outStruct,
232  bytesBuf_t *outBsBBuf ) {
233  int status = 0;
234  msgHeader_t myHeader;
235  /* bytesBuf_t outStructBBuf, errorBBuf, myOutBsBBuf; */
236  bytesBuf_t outStructBBuf, errorBBuf;
237 
238  cliChkReconnAtReadStart( conn );
239 
240  memset( &outStructBBuf, 0, sizeof( bytesBuf_t ) );
241  memset( &errorBBuf, 0, sizeof( bytesBuf_t ) );
242  /* memset (&myOutBsBBuf, 0, sizeof (bytesBuf_t)); */
243 
244  /* some sanity check */
245 
247  if ( RcApiTable[apiInx]->outPackInstruct != NULL && outStruct == NULL ) {
249  "readAndProcApiReply: outStruct error for A apiNumber %d",
250  RcApiTable[apiInx]->apiNumber );
251  cliChkReconnAtReadEnd( conn );
252  return USER_API_INPUT_ERR;
253  }
254 
255  if ( RcApiTable[apiInx]->outBsFlag > 0 && outBsBBuf == NULL ) {
257  "readAndProcApiReply: outBsBBuf error for B apiNumber %d",
258  RcApiTable[apiInx]->apiNumber );
259  cliChkReconnAtReadEnd( conn );
260  return USER_API_INPUT_ERR;
261  }
262 
264  irods::error ret = irods::network_factory( conn, net_obj );
265  if ( !ret.ok() ) {
266  irods::log( PASS( ret ) );
267  return ret.code();
268  }
269 
270  ret = readMsgHeader( net_obj, &myHeader, NULL );
271  if ( !ret.ok() ) {
272 #ifdef RODS_CLERVER
273  irods::log( PASS( ret ) );
274 #else
275  if (ret.code() == SYS_HEADER_READ_LEN_ERR) {
276  ret = CODE(SYS_INTERNAL_ERR);
277  }
278 #endif
279  if ( conn->svrVersion != NULL && conn->svrVersion->reconnPort > 0 ) {
280  int savedStatus = ret.code();
281  /* try again. the socket might have changed */
282  conn->thread_ctx->lock->lock();
284  "readAndProcClientMsg:svrSwitchConnect.cliState = %d,agState=%d",
285  conn->clientState, conn->agentState );
286  cliSwitchConnect( conn );
287  conn->thread_ctx->lock->unlock();
288  ret = readMsgHeader( net_obj, &myHeader, NULL );
289 
290  if ( !ret.ok() ) {
291  cliChkReconnAtReadEnd( conn );
292  return savedStatus;
293  }
294  }
295  else {
296  cliChkReconnAtReadEnd( conn );
297  return ret.code();
298  }
299 
300  } // if !ret.ok
301 
302  ret = readMsgBody( net_obj, &myHeader, &outStructBBuf, outBsBBuf,
303  &errorBBuf, conn->irodsProt, NULL );
304  if ( !ret.ok() ) {
305  irods::log( PASS( ret ) );
306  cliChkReconnAtReadEnd( conn );
307  return status;
308  } // if !ret.ok
309 
310  cliChkReconnAtReadEnd( conn );
311 
312  if ( strcmp( myHeader.type, RODS_API_REPLY_T ) == 0 ) {
313  status = procApiReply( conn, apiInx, outStruct, outBsBBuf,
314  &myHeader, &outStructBBuf, NULL, &errorBBuf );
315  }
316 
317  clearBBuf( &outStructBBuf );
318  /* clearBBuf (&myOutBsBBuf); */
319  clearBBuf( &errorBBuf );
320 
321  return status;
322 }
323 
324 int
325 procApiReply( rcComm_t *conn, int apiInx, void **outStruct,
326  bytesBuf_t *outBsBBuf,
327  msgHeader_t *myHeader, bytesBuf_t *outStructBBuf, bytesBuf_t *myOutBsBBuf,
328  bytesBuf_t *errorBBuf ) {
329  int status;
330  int retVal;
331 
332  if ( errorBBuf->len > 0 ) {
333  status = unpackStruct( errorBBuf->buf, ( void ** )( static_cast< void * >( &conn->rError ) ),
334  "RError_PI", RodsPackTable, conn->irodsProt );
335  if ( status < 0 ) {
337  "readAndProcApiReply:unpackStruct error. status = %d",
338  status );
339  }
340  }
341 
342  retVal = myHeader->intInfo;
343 
344  /* some sanity check */
345 
347  if ( RcApiTable[apiInx]->outPackInstruct != NULL && outStruct == NULL ) {
349  "readAndProcApiReply: outStruct error for C apiNumber %d",
350  RcApiTable[apiInx]->apiNumber );
351  if ( retVal < 0 ) {
352  return retVal;
353  }
354  else {
355  return USER_API_INPUT_ERR;
356  }
357  }
358 
359  if ( RcApiTable[apiInx]->outBsFlag > 0 && outBsBBuf == NULL ) {
361  "readAndProcApiReply: outBsBBuf error for D apiNumber %d",
362  RcApiTable[apiInx]->apiNumber );
363  if ( retVal < 0 ) {
364  return retVal;
365  }
366  else {
367  return USER_API_INPUT_ERR;
368  }
369  }
370 
371  /* handle outStruct */
372  if ( outStructBBuf->len > 0 ) {
373  if ( outStruct != NULL ) {
374  status = unpackStruct( outStructBBuf->buf, ( void ** ) outStruct,
375  ( char* )RcApiTable[apiInx]->outPackInstruct, RodsPackTable,
376  conn->irodsProt );
377  if ( status < 0 ) {
379  "readAndProcApiReply:unpackStruct error. status = %d",
380  status );
381  if ( retVal < 0 ) {
382  return retVal;
383  }
384  else {
385  return status;
386  }
387  }
388  }
389  else {
391  "readAndProcApiReply: got unneeded outStruct for apiNumber %d",
392  RcApiTable[apiInx]->apiNumber );
393  }
394  }
395 
396  if ( myOutBsBBuf != NULL && myOutBsBBuf->len > 0 ) {
397  if ( outBsBBuf != NULL ) {
398  /* copy to out */
399  *outBsBBuf = *myOutBsBBuf;
400  memset( myOutBsBBuf, 0, sizeof( bytesBuf_t ) );
401  }
402  else {
404  "readAndProcApiReply: got unneeded outBsBBuf for apiNumber %d",
405  RcApiTable[apiInx]->apiNumber );
406  }
407  }
408 
409  return retVal;
410 }
411 
412 int
413 cliGetCollOprStat( rcComm_t *conn, collOprStat_t *collOprStat, int vFlag,
414  int retval ) {
415  int status = retval;
416 
417  while ( status == SYS_SVR_TO_CLI_COLL_STAT ) {
418  /* more to come */
419  if ( collOprStat != NULL ) {
420  if ( vFlag != 0 ) {
421  printf( "num files done = %d, ", collOprStat->filesCnt );
422  if ( collOprStat->totalFileCnt <= 0 ) {
423  printf( "totalFileCnt = UNKNOWN, " );
424  }
425  else {
426  printf( "totalFileCnt = %d, ", collOprStat->totalFileCnt );
427  }
428  printf( "bytesWritten = %lld, last file done: %s\n",
429  collOprStat->bytesWritten, collOprStat->lastObjPath );
430  }
431  free( collOprStat );
432  collOprStat = NULL;
433  }
434  status = _cliGetCollOprStat( conn, &collOprStat );
435  }
436 
437  if ( collOprStat != NULL ) {
438  free( collOprStat );
439  }
440 
441  return status;
442 }
443 
444 int
445 _cliGetCollOprStat( rcComm_t *conn, collOprStat_t **collOprStat ) {
446  int myBuf = htonl( SYS_CLI_TO_SVR_COLL_STAT_REPLY );
448  if (int bytes_left = 4 - sslWrite(static_cast<void*>(&myBuf), 4, NULL, conn->ssl)) {
449  rodsLogError( LOG_ERROR, SYS_SOCK_WRITE_ERR, "sslWrite exited with %d bytes still left to write in %s.", bytes_left, __PRETTY_FUNCTION__ );
450  return SYS_SOCK_WRITE_ERR;
451  }
452  } else {
453  if (int bytes_left = 4 - myWrite( conn->sock, ( void * ) &myBuf, 4, NULL )) {
454  rodsLogError( LOG_ERROR, SYS_SOCK_WRITE_ERR, "myWrite exited with %d bytes still left to write in %s.", bytes_left, __PRETTY_FUNCTION__ );
455  return SYS_SOCK_WRITE_ERR;
456  }
457  }
458  return readAndProcApiReply( conn, conn->apiInx, ( void ** ) collOprStat, NULL );
459 }
460 
461 int apiTableLookup(int apiNumber)
462 {
463  if (auto& api_table = irods::get_client_api_table();
464  api_table.find(apiNumber) != std::end(api_table))
465  {
466  return apiNumber;
467  }
468 
469 #if defined(RODS_SERVER) || defined(RODS_CLERVER)
470  if (auto& api_table = irods::get_server_api_table();
471  api_table.find(apiNumber) != std::end(api_table))
472  {
473  return apiNumber;
474  }
475 #endif // RODS_SERVER || RODS_CLERVER
476 
477  return SYS_UNMATCHED_API_NUM;
478 }
rodsLog
void rodsLog(int level, const char *formatStr,...)
Definition: rodsLog.cpp:86
rcComm_t
Definition: rcConnect.h:95
NULL
#define NULL
Definition: rodsDef.h:70
rcComm_t::agentState
procState_t agentState
Definition: rcConnect.h:116
msgHeader
Definition: rodsDef.h:210
apiTableLookup
int apiTableLookup(int apiNumber)
Definition: procApiRequest.cpp:461
readMsgBody
irods::error readMsgBody(irods::network_object_ptr, msgHeader_t *, bytesBuf_t *, bytesBuf_t *, bytesBuf_t *, irodsProt_t, struct timeval *)
Definition: sockComm.cpp:236
BytesBuf::buf
void * buf
Definition: rodsDef.h:199
procApiRequest
int procApiRequest(rcComm_t *conn, int apiNumber, void *inputStruct, bytesBuf_t *inputBsBBuf, void **outStruct, bytesBuf_t *outBsBBuf)
Definition: procApiRequest.cpp:55
PASS
#define PASS(prev_error_)
Definition: irods_error.hpp:118
msgHeader::type
char type[128]
Definition: rodsDef.h:211
cliChkReconnAtSendStart
int cliChkReconnAtSendStart(rcComm_t *conn)
Definition: rcConnect.cpp:512
collOprStat_t::filesCnt
int filesCnt
Definition: objInfo.h:299
sslSockComm.h
rcComm_t::rError
rError_t * rError
Definition: rcConnect.h:106
freeRError
int freeRError(rError_t *myError)
Definition: rcMisc.cpp:170
rcMisc.h
irods_threads.hpp
procApiReply
int procApiReply(rcComm_t *conn, int apiInx, void **outStruct, bytesBuf_t *outBsBBuf, msgHeader_t *myHeader, bytesBuf_t *outStructBBuf, bytesBuf_t *myOutBsBBuf, bytesBuf_t *errorBBuf)
Definition: procApiRequest.cpp:325
irods::lookup_table< api_entry_ptr, size_t, boost::hash< size_t > >::iterator
irods_hash_map::iterator iterator
Definition: irods_lookup_table.hpp:31
unpackStruct
int unpackStruct(const void *inPackStr, void **outStruct, const char *packInstName, const packInstruct_t *myPackTable, irodsProt_t irodsProt)
Definition: packStruct.cpp:63
cliChkReconnAtSendEnd
int cliChkReconnAtSendEnd(rcComm_t *conn)
Definition: rcConnect.cpp:545
readMsgHeader
irods::error readMsgHeader(irods::network_object_ptr, msgHeader_t *, struct timeval *)
Definition: sockComm.cpp:173
rcGlobalExtern.h
LOG_ERROR
#define LOG_ERROR
Definition: rodsLog.h:43
collOprStat_t::lastObjPath
char lastObjPath[(1024+64)]
Definition: objInfo.h:302
SYS_UNMATCHED_API_NUM
@ SYS_UNMATCHED_API_NUM
Definition: rodsErrorTable.h:80
BytesBuf::len
int len
Definition: rodsDef.h:198
rcComm_t::apiInx
int apiInx
Definition: rcConnect.h:109
SYS_INTERNAL_ERR
@ SYS_INTERNAL_ERR
Definition: rodsErrorTable.h:211
irods::experimental::filesystem::client::end
auto end(const collection_iterator &) noexcept -> const collection_iterator
Definition: collection_iterator.hpp:88
irods_network_factory.hpp
SYS_HEADER_READ_LEN_ERR
@ SYS_HEADER_READ_LEN_ERR
Definition: rodsErrorTable.h:72
irods::error::code
long long code() const
Definition: irods_error.cpp:194
irods::network_factory
irods::error network_factory(rcComm_t *, irods::network_object_ptr &)
Definition: irods_network_factory.cpp:8
cliChkReconnAtReadStart
int cliChkReconnAtReadStart(rcComm_t *conn)
Definition: rcConnect.cpp:567
cliChkReconnAtReadEnd
int cliChkReconnAtReadEnd(rcComm_t *conn)
Definition: rcConnect.cpp:585
LOG_DEBUG
#define LOG_DEBUG
Definition: rodsLog.h:23
myWrite
int myWrite(int sock, void *buf, int len, int *bytesWritten)
Definition: rcMisc.cpp:4610
collOprStat_t
Definition: objInfo.h:298
irods::get_server_api_table
api_entry_table & get_server_api_table()
Definition: irods_server_api_table.cpp:8
procApiRequest.h
sslWrite
int sslWrite(void *buf, int len, int *bytesWritten, SSL *ssl)
Definition: sslSockComm.cpp:563
_cliGetCollOprStat
int _cliGetCollOprStat(rcComm_t *conn, collOprStat_t **collOprStat)
Definition: procApiRequest.cpp:445
collOprStat_t::totalFileCnt
int totalFileCnt
Definition: objInfo.h:300
collOprStat_t::bytesWritten
rodsLong_t bytesWritten
Definition: objInfo.h:301
irods::CS_NEG_USE_SSL
const std::string CS_NEG_USE_SSL("CS_NEG_USE_SSL")
irods_server_api_table.hpp
SYS_SVR_TO_CLI_COLL_STAT
#define SYS_SVR_TO_CLI_COLL_STAT
Definition: rodsDef.h:110
USER_API_INPUT_ERR
@ USER_API_INPUT_ERR
Definition: rodsErrorTable.h:238
branchReadAndProcApiReply
int branchReadAndProcApiReply(rcComm_t *conn, int apiNumber, void **outStruct, bytesBuf_t *outBsBBuf)
Definition: procApiRequest.cpp:94
irods::lookup_table::find
iterator find(KeyType _k)
Definition: irods_lookup_table.hpp:65
rcComm_t::ssl
SSL * ssl
Definition: rcConnect.h:130
irods.pypyodbc.status
status
Definition: pypyodbc.py:467
sendRodsMsg
irods::error sendRodsMsg(irods::network_object_ptr, const char *, bytesBuf_t *, bytesBuf_t *, bytesBuf_t *, int, irodsProt_t)
Definition: sockComm.cpp:1221
rcComm_t::clientState
procState_t clientState
Definition: rcConnect.h:117
irods::log
void log(const error &)
Definition: irods_log.cpp:13
SYS_SOCK_WRITE_ERR
@ SYS_SOCK_WRITE_ERR
Definition: rodsErrorTable.h:218
LOG_NOTICE
#define LOG_NOTICE
Definition: rodsLog.h:33
rcComm_t::thread_ctx
struct thread_context * thread_ctx
Definition: rcConnect.h:115
irods::lookup_table::end
iterator end()
Definition: irods_lookup_table.hpp:56
RodsPackTable
const packInstruct_t RodsPackTable[]
Definition: rodsPackTable.h:61
BytesBuf
Definition: rodsDef.h:197
irods::error
Definition: irods_error.hpp:23
irods_client_api_table.hpp
cliSwitchConnect
int cliSwitchConnect(rcComm_t *conn)
Definition: sockComm.cpp:1438
irods::api_entry_table
Definition: apiHandler.hpp:353
RODS_API_REQ_T
#define RODS_API_REQ_T
Definition: rodsDef.h:226
msgHeader::intInfo
int intInfo
Definition: rodsDef.h:215
sendApiRequest
int sendApiRequest(rcComm_t *conn, int apiInx, void *inputStruct, bytesBuf_t *inputBsBBuf)
Definition: procApiRequest.cpp:123
cliGetCollOprStat
int cliGetCollOprStat(rcComm_t *conn, collOprStat_t *collOprStat, int vFlag, int retval)
Definition: procApiRequest.cpp:413
irods::network_object_ptr
boost::shared_ptr< network_object > network_object_ptr
Definition: irods_network_object.hpp:78
rodsLogError
void rodsLogError(int level, int errCode, char *formatStr,...)
Definition: rodsLog.cpp:422
packStruct
int packStruct(const void *inStruct, bytesBuf_t **packedResult, const char *packInstName, const packInstruct_t *myPackTable, int packFlag, irodsProt_t irodsProt)
Definition: packStruct.cpp:21
rcComm_t::svrVersion
version_t * svrVersion
Definition: rcConnect.h:105
sockComm.h
freeBBuf
int freeBBuf(bytesBuf_t *myBBuf)
Definition: rcMisc.cpp:88
rcComm_t::irodsProt
irodsProt_t irodsProt
Definition: rcConnect.h:96
irods::get_client_api_table
api_entry_table & get_client_api_table()
Definition: irods_client_api_table.cpp:8
version_t::reconnPort
int reconnPort
Definition: rodsDef.h:290
clearBBuf
int clearBBuf(bytesBuf_t *myBBuf)
Definition: rcMisc.cpp:101
CODE
#define CODE(code_)
Definition: irods_error.hpp:120
sockCommNetworkInterface.hpp
irods::error::ok
bool ok()
Definition: irods_error.cpp:258
readAndProcApiReply
int readAndProcApiReply(rcComm_t *conn, int apiInx, void **outStruct, bytesBuf_t *outBsBBuf)
Definition: procApiRequest.cpp:231
thread_context::lock
boost::mutex * lock
Definition: irods_threads.hpp:12
irods_client_server_negotiation.hpp
rcComm_t::negotiation_results
char negotiation_results[(1024+64)]
Definition: rcConnect.h:125
SYS_CLI_TO_SVR_COLL_STAT_REPLY
#define SYS_CLI_TO_SVR_COLL_STAT_REPLY
Definition: rodsDef.h:111
RODS_API_REPLY_T
#define RODS_API_REPLY_T
Definition: rodsDef.h:230
USER__NULL_INPUT_ERR
@ USER__NULL_INPUT_ERR
Definition: rodsErrorTable.h:247
rcComm_t::sock
int sock
Definition: rcConnect.h:98