int
isioFlush( int fileIndex ) {
int i;
int status;
openedDataObjInp_t dataObjWriteInp;
bytesBuf_t dataObjWriteOutBBuf;
i = fileIndex;
if ( debug ) {
printf( "isioFlush: %d\n", i );
}
if ( cacheInfo[i].written > 0 ) {
dataObjWriteOutBBuf.buf = cacheInfo[i].base;
dataObjWriteOutBBuf.len = cacheInfo[i].written;
memset( &dataObjWriteInp, 0, sizeof( dataObjWriteInp ) );
dataObjWriteInp.l1descInx = openFiles[fileIndex];
dataObjWriteInp.len = cacheInfo[i].written;
if ( debug ) printf( "isioFlush: writing %d\n",
cacheInfo[i].written );
status = rcDataObjWrite( Comm, &dataObjWriteInp,
&dataObjWriteOutBBuf );
if ( status >= 0 ) {
cacheInfo[i].ptr = cacheInfo[i].base;
cacheInfo[i].written = 0;
}
return status;
}
return 0;
}
int
irods_file_write_( int *fd, void *buffer, int *size ) {
openedDataObjInp_t dataObjWriteInp;
bytesBuf_t dataObjWriteOutBBuf;
int status;
char *cp1;
if ( debug ) {
printf( "irods_file_write_\n" );
}
dataObjWriteOutBBuf.buf = buffer;
dataObjWriteOutBBuf.len = *size;
memset( &dataObjWriteInp, 0, sizeof( dataObjWriteInp ) );
dataObjWriteInp.l1descInx = *fd;
dataObjWriteInp.len = *size;
status = rcDataObjWrite( Comm, &dataObjWriteInp,
&dataObjWriteOutBBuf );
if ( debug ) {
printf( "irods_file_write_ rcDataObjWrite stat: %d\n", status );
}
return status;
}
int irods_reli_pwrite ( struct irods_file *file, const char *data, int length, INT64_T offset )
{
int result;
openedDataObjInp_t request;
bytesBuf_t response;
struct irods_server *server = connect_to_host(file->host);
if(!server) return -1;
if(!connect_to_file(server,file)) return -1;
if(irods_reli_lseek_if_needed(file,offset)<0) return -1;
memset(&request,0,sizeof(request));
request.l1descInx = file->fd;
request.len = length;
response.buf = (char*)data;
response.len = length;
debug(D_IRODS,"rcDataObjWrite %s %d %d",file->host,file->fd,length);
result = rcDataObjWrite(server->conn,&request,&response);
debug(D_IRODS,"= %d",result);
if(result<0) {
errno = irods_reli_errno(result);
return -1;
}
file->offset += result;
return result;
}
static ssize_t irods_write(hFILE *fpv, const void *buffer, size_t nbytes)
{
hFILE_irods *fp = (hFILE_irods *) fpv;
openedDataObjInp_t args;
bytesBuf_t buf;
int ret;
memset(&args, 0, sizeof args);
args.l1descInx = fp->descriptor;
args.len = nbytes;
buf.buf = (void *) buffer; // ...the iRODS API is not const-correct here
buf.len = nbytes;
ret = rcDataObjWrite(irods.conn, &args, &buf);
if (ret < 0) set_errno(ret);
return ret;
}
int
isioFileWrite( int fileIndex, void *buffer, int countToWrite ) {
int status;
int spaceInBuffer;
int newBufSize;
openedDataObjInp_t dataObjWriteInp;
bytesBuf_t dataObjWriteOutBBuf;
if ( debug ) {
printf( "isioFileWrite: %d\n", fileIndex );
}
if ( cacheInfo[fileIndex].count > 0 ) {
/* buffer has read data in it, so seek to where the
the app thinks the pointer is and disgard the buffered
read data */
long offset;
offset = - cacheInfo[fileIndex].count;
status = isioFileSeek( fileIndex, offset, SEEK_CUR );
if ( status ) {
return status;
}
cacheInfo[fileIndex].ptr = cacheInfo[fileIndex].base;
cacheInfo[fileIndex].count = 0;
}
spaceInBuffer = cacheInfo[fileIndex].bufferSize -
cacheInfo[fileIndex].written;
if ( debug ) {
printf( "isioFileWrite: spaceInBuffer %d\n", spaceInBuffer );
}
if ( countToWrite < spaceInBuffer ) {
/* Fits in the buffer, just cache it */
if ( debug ) printf( "isioFileWrite: caching 1 %x %d\n",
( int ) cacheInfo[fileIndex].ptr, countToWrite );
memcpy( cacheInfo[fileIndex].ptr, buffer, countToWrite );
cacheInfo[fileIndex].ptr += countToWrite;
cacheInfo[fileIndex].written += countToWrite;
return countToWrite;
}
status = isioFlush( fileIndex ); /* if anything is buffered, flush it */
if ( status < 0 ) {
return status;
}
if ( countToWrite > ISIO_MAX_BUF_SIZE ) {
/* Too big to cache, just send it */
dataObjWriteOutBBuf.buf = buffer;
dataObjWriteOutBBuf.len = countToWrite;
memset( &dataObjWriteInp, 0, sizeof( dataObjWriteInp ) );
dataObjWriteInp.l1descInx = openFiles[fileIndex];
dataObjWriteInp.len = countToWrite;
status = rcDataObjWrite( Comm, &dataObjWriteInp,
&dataObjWriteOutBBuf );
if ( debug ) {
printf( "isioFileWrite: rcDataWrite 2 %d\n", status );
}
if ( status < 0 ) {
return status;
}
return ( status ); /* total bytes written */
}
newBufSize = ( 2 * countToWrite ) + 8; /* Possible next size */
if ( newBufSize > ISIO_MAX_BUF_SIZE ) {
newBufSize = ISIO_MAX_BUF_SIZE;
}
if ( newBufSize > cacheInfo[fileIndex].bufferSize ) {
/* free old and make new larger buffer */
int i = fileIndex;
if ( cacheInfo[i].usingUsersBuffer == 'n' ) {
if ( debug ) {
printf( "isioFilewrite calling free\n" );
}
free( cacheInfo[i].base );
}
if ( debug ) printf( "isioFilewrite calling malloc %d\n",
newBufSize );
cacheInfo[i].base = ( char * )malloc( newBufSize );
if ( cacheInfo[i].base == NULL ) {
fprintf( stderr, "Memory Allocation error\n" );
return 0;
}
cacheInfo[i].bufferSize = newBufSize;
cacheInfo[i].usingUsersBuffer = 'n';
cacheInfo[i].ptr = cacheInfo[i].base;
}
/* Now it fits in the buffer, so cache it */
if ( debug ) printf( "isioFileWrite: caching 2 %x %d\n",
( int ) cacheInfo[fileIndex].ptr, countToWrite );
memcpy( cacheInfo[fileIndex].ptr, buffer, countToWrite );
cacheInfo[fileIndex].ptr += countToWrite;
cacheInfo[fileIndex].count -= countToWrite; //??
cacheInfo[fileIndex].written += countToWrite;
return countToWrite;
}
int _ifuseFileCacheWrite( fileCache_t *fileCache, char *buf, size_t size, off_t offset ) {
int status, myError;
openedDataObjInp_t dataObjWriteInp;
bytesBuf_t dataObjWriteInpBBuf;
iFuseConn_t *conn;
bzero( &dataObjWriteInp, sizeof( dataObjWriteInp ) );
/* lseek to the right offset in case this cache is share by multiple descs */
status = _iFuseFileCacheLseek( fileCache, offset );
if ( status < 0 ) {
if ( ( myError = getErrno( status ) ) > 0 ) {
return -myError;
}
else {
return -ENOENT;
}
}
if ( fileCache->state == NO_FILE_CACHE ) {
/* no file cache */
dataObjWriteInpBBuf.buf = ( void * ) buf;
dataObjWriteInpBBuf.len = size;
dataObjWriteInp.l1descInx = fileCache->iFd;
dataObjWriteInp.len = size;
conn = getAndUseConnByPath( fileCache->localPath, &status );
status = rcDataObjWrite( conn->conn, &dataObjWriteInp, &dataObjWriteInpBBuf );
unuseIFuseConn( conn );
if ( status < 0 ) {
if ( ( myError = getErrno( status ) ) > 0 ) {
return -myError;
}
else {
return -ENOENT;
}
}
else if ( status != ( int ) size ) {
rodsLog( LOG_ERROR,
"ifuseWrite: IFuseDesc[descInx].conn for %s is NULL", fileCache->localPath );
return -ENOENT;
}
fileCache->offset += status;
if ( fileCache->offset > fileCache->fileSize ) {
fileCache->fileSize = fileCache->offset;
}
}
else {
status = write( fileCache->iFd, buf, size );
if ( status < 0 ) {
return errno ? ( -1 * errno ) : -1;
}
fileCache->offset += status;
if ( fileCache->offset > fileCache->fileSize ) {
fileCache->fileSize = fileCache->offset;
}
if ( fileCache->offset >= MAX_NEWLY_CREATED_CACHE_SIZE ) {
_iFuseFileCacheFlush( fileCache );
fileCache->iFd = 0;
/* reopen file */
dataObjInp_t dataObjOpenInp;
memset( &dataObjOpenInp, 0, sizeof( dataObjOpenInp ) );
rstrcpy( dataObjOpenInp.objPath, fileCache->objPath, MAX_NAME_LEN );
dataObjOpenInp.openFlags = O_RDWR;
int status;
conn = getAndUseConnByPath( fileCache->localPath, &status );
status = rcDataObjOpen( conn->conn, &dataObjOpenInp );
unuseIFuseConn( conn );
if ( status < 0 ) {
rodsLog( LOG_ERROR, "iFuseWrite: rcDataObjOpen of %s error. status = %d", fileCache->objPath, status );
return -ENOENT;
}
fileCache->iFd = status;
}
}
return status;
}
int
irodsSymlink (const char *to, const char *from)
{
int status;
iFuseConn_t *iFuseConn = NULL;
int l1descInx;
dataObjInp_t dataObjOpenInp;
openedDataObjInp_t dataObjWriteInp;
bytesBuf_t dataObjWriteOutBBuf;
char collPath[MAX_NAME_LEN];
struct stat stbuf;
rodsLog (LOG_DEBUG, "irodsSymlink: %s to %s", from, to);
status = parseRodsPathStr ((char *) (from + 1), &MyRodsEnv, collPath);
if (status < 0) {
rodsLogError (LOG_ERROR, status,
"irodsReaddir: parseRodsPathStr of %s error", from);
/* use ENOTDIR for this type of error */
return -ENOTDIR;
}
iFuseConn = getAndUseConnByPath ((char *) from, &MyRodsEnv, &status);
status = _irodsGetattr(iFuseConn, (char *) from, &stbuf);
memset (&dataObjOpenInp, 0, sizeof (dataObjOpenInp));
rstrcpy (dataObjOpenInp.objPath, collPath, MAX_NAME_LEN);
if(status != -ENOENT) {
if (status < 0) {
return status;
}
dataObjOpenInp.dataSize = 0;
status = rcDataObjTruncate(iFuseConn->conn, &dataObjOpenInp);
if (status < 0) {
rodsLog (LOG_ERROR, "irodsReadlink: rcDataObjTruncate of %s error. status = %d", collPath, status);
unuseIFuseConn (iFuseConn);
return -ENOENT;
}
}
memset (&dataObjOpenInp, 0, sizeof (dataObjOpenInp));
rstrcpy (dataObjOpenInp.objPath, collPath, MAX_NAME_LEN);
dataObjOpenInp.openFlags = O_WRONLY | O_CREAT;
dataObjOpenInp.createMode = S_IFLNK;
status = rcDataObjOpen (iFuseConn->conn, &dataObjOpenInp);
if (status < 0) {
rodsLog (LOG_ERROR, "irodsSymlink: rcDataObjOpen of %s error. status = %d", collPath, status);
unuseIFuseConn (iFuseConn);
return -ENOENT;
}
l1descInx = status;
memset(&dataObjWriteInp, 0, sizeof (dataObjWriteInp));
memset(&dataObjWriteOutBBuf, 0, sizeof (bytesBuf_t));
dataObjWriteInp.l1descInx = l1descInx;
dataObjWriteInp.len = strlen(to);
dataObjWriteOutBBuf.len = strlen(to);
dataObjWriteOutBBuf.buf = strdup(to);
status = rcDataObjWrite (iFuseConn->conn, &dataObjWriteInp, &dataObjWriteOutBBuf);
free(dataObjWriteOutBBuf.buf);
if (status < 0) {
rodsLog (LOG_ERROR, "irodsSymlink: rcDataObjWrite of %s error. status = %d", collPath, status);
unuseIFuseConn (iFuseConn);
return -ENOENT;
}
rcDataObjClose(iFuseConn->conn, &dataObjWriteInp);
unuseIFuseConn (iFuseConn);
return (0);
}
int main (int argc, char **argv) {
rcComm_t *conn = NULL;
rodsEnv irods_env;
rErrMsg_t err_msg;
dataObjInp_t data_obj;
openedDataObjInp_t open_obj;
int open_fd;
char *new_host = NULL;
int status;
char *obj_name = NULL;
char *buffer;
char prog_name[255];
size_t buf_size = DEFAULT_BUFFER_SIZE;
int verbose = 0;
int opt;
unsigned long total_written = 0;
int write_to_irods = 1;
int server_set = 0;
while ((opt = getopt(argc, argv, "b:vhrdw")) != -1) {
switch (opt) {
case 'b':
buf_size = atoi(optarg);
if (buf_size <= 0) {
error_and_exit(conn, "Error: buffer size must be greater than 0.\n");
}
break;
case 'v':
verbose = 1;
break;
case 'r':
write_to_irods = 0;
break;
case 'w':
// dummy write option to be enforced later
break;
case 'd':
server_set = 1;
break;
case 'h':
usage_and_exit(argv[0], EXIT_SUCCESS);
break;
default:
usage_and_exit(argv[0], EXIT_FAILURE);
break;
}
}
if (optind >= argc) {
fprintf(stderr, "Error: Missing iRODS file.\n");
usage_and_exit(argv[0], EXIT_FAILURE);
}
obj_name = argv[optind];
if ((buffer = malloc(buf_size)) == NULL) {
error_and_exit(conn, "Error: unable to set buffer to size %ld\n", buf_size);
}
// set the client name so iRODS knows what program is connecting to it
sprintf(prog_name, "%s:%s", PACKAGE_NAME, PACKAGE_VERSION);
if (verbose) {
fprintf(stderr, "Setting client name to: %s\n", prog_name);
}
setenv(SP_OPTION, prog_name, 1);
// lets get the irods environment
if ((status = getRodsEnv(&irods_env)) < 0) {
error_and_exit(conn, "Error: getRodsEnv failed with status %d:%s\n", status, get_irods_error_name(status, verbose));
}
if ((status = irods_uri_check(obj_name, &irods_env, verbose)) < 0) {
error_and_exit(conn, "Error: invalid uri: %s\n", obj_name);
} else if (status > 0) {
server_set = 1;
}
if (verbose) {
fprintf(stderr, "host %s\nzone %s\nuser %s\nport %d\n",
irods_env.rodsHost, irods_env.rodsZone,
irods_env.rodsUserName, irods_env.rodsPort);
}
#if IRODS_VERSION_INTEGER && IRODS_VERSION_INTEGER >= 4001008
init_client_api_table();
#endif
// make the irods connections
conn = rcConnect(irods_env.rodsHost, irods_env.rodsPort,
irods_env.rodsUserName, irods_env.rodsZone,
0, &err_msg);
if (!conn) {
print_irods_error("Error: rcConnect failed:", &err_msg);
exit(EXIT_FAILURE);
}
#if IRODS_VERSION_INTEGER && IRODS_VERSION_INTEGER >= 4001008
status = clientLogin(conn, "", "");
#else
status = clientLogin(conn);
#endif
if (status < 0) {
error_and_exit(conn, "Error: clientLogin failed with status %d:%s\n", status, get_irods_error_name(status, verbose));
}
// set up the data object
memset(&data_obj, 0, sizeof(data_obj));
strncpy(data_obj.objPath, obj_name, MAX_NAME_LEN);
if (write_to_irods) {
data_obj.openFlags = O_WRONLY;
} else {
data_obj.openFlags = O_RDONLY;
}
data_obj.dataSize = 0;
// talk to server
if (write_to_irods) {
if (!server_set) {
if ((status = rcGetHostForPut(conn, &data_obj, &new_host)) < 0) {
error_and_exit(conn, "Error: rcGetHostForPut failed with status %d:%s\n", status, get_irods_error_name(status, verbose));
}
choose_server(&conn, new_host, &irods_env, verbose);
free(new_host);
}
if ((open_fd = rcDataObjCreate(conn, &data_obj)) < 0) {
error_and_exit(conn, "Error: rcDataObjCreate failed with status %d:%s\n", open_fd, get_irods_error_name(open_fd, verbose));
}
} else {
if (!server_set) {
if ((status = rcGetHostForGet(conn, &data_obj, &new_host)) < 0) {
error_and_exit(conn, "Error: rcGetHostForGet failed with status %d:%s\n", status, get_irods_error_name(status, verbose));
}
choose_server(&conn, new_host, &irods_env, verbose);
free(new_host);
}
if ((open_fd = rcDataObjOpen(conn, &data_obj)) < 0) {
error_and_exit(conn, "Error: rcDataObjOpen failed with status %d:%s\n", open_fd, get_irods_error_name(open_fd, verbose));
}
}
// the read/write loop
while (1) {
bytesBuf_t data_buffer;
long read_in;
long written_out;
// set up common data elements
memset(&open_obj, 0, sizeof(open_obj));
open_obj.l1descInx = open_fd;
data_buffer.buf = buffer;
// time to read something
if (write_to_irods) {
read_in = fread(buffer, 1, buf_size, stdin);
open_obj.len = read_in;
data_buffer.len = open_obj.len;
} else {
open_obj.len = buf_size;
data_buffer.len = open_obj.len;
if ((read_in = rcDataObjRead(conn, &open_obj, &data_buffer)) < 0) {
error_and_exit(conn, "Error: rcDataObjRead failed with status %ld:%s\n", read_in, get_irods_error_name(read_in, verbose));
}
}
if (verbose) {
fprintf(stderr, "%ld bytes read\n", read_in);
}
if (!read_in) break;
// now try and write something
if (write_to_irods) {
open_obj.len = read_in;
data_buffer.len = open_obj.len;
if ((written_out = rcDataObjWrite(conn, &open_obj, &data_buffer)) < 0) {
error_and_exit(conn, "Error: rcDataObjWrite failed with status %ld\n", written_out, get_irods_error_name(written_out, verbose));
}
} else {
written_out = fwrite(buffer, 1, read_in, stdout);
}
if (verbose) {
fprintf(stderr, "%ld bytes written\n", written_out);
}
total_written += written_out;
if (read_in != written_out) {
error_and_exit(conn, "Error: write fail %ld written, should be %ld.\n", written_out, read_in);
}
};
if (verbose) {
fprintf(stderr, "Total bytes written %ld\n", total_written);
}
if ((status = rcDataObjClose(conn, &open_obj)) < 0) {
error_and_exit(conn, "Error: rcDataObjClose failed with status %d:%s\n", status, get_irods_error_name(status, verbose));
}
rcDisconnect(conn);
free(buffer);
exit(EXIT_SUCCESS);
}