/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Copyright by the Board of Trustees of the University of Illinois. *
* All rights reserved. *
* *
* This file is part of HDF5. The full HDF5 copyright notice, including *
* terms governing use, modification, and redistribution, is contained in *
* the files COPYING and Copyright.html. COPYING can be found at the root *
* of the source code distribution tree; Copyright.html can be found at the *
* root level of an installed copy of the electronic HDF5 document set and *
* is linked from the top-level documents page. It can also be found at *
* http://hdf.ncsa.uiuc.edu/HDF5/doc/Copyright.html. If you do not have *
* access to either file, you may request a copy from hdfhelp@ncsa.uiuc.edu. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*-------------------------------------------------------------------------
*
* Created: H5Olink.c
* Aug 29 2005
* Quincey Koziol <koziol@ncsa.uiuc.edu>
*
* Purpose: Link messages.
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
#define H5O_PACKAGE /*suppress error about including H5Opkg */
#include "H5private.h" /* Generic Functions */
#include "H5Eprivate.h" /* Error handling */
#include "H5FLprivate.h" /* Free lists */
#include "H5MMprivate.h" /* Memory management */
#include "H5Opkg.h" /* Object headers */
#ifdef H5_GROUP_REVISION
/* PRIVATE PROTOTYPES */
static void *H5O_link_decode(H5F_t *f, hid_t dxpl_id, const uint8_t *p);
static herr_t H5O_link_encode(H5F_t *f, uint8_t *p, const void *_mesg);
static size_t H5O_link_size(const H5F_t *f, const void *_mesg);
static herr_t H5O_link_reset(void *_mesg);
static herr_t H5O_link_free(void *_mesg);
static herr_t H5O_link_delete(H5F_t *f, hid_t dxpl_id, const void *_mesg, hbool_t adj_link);
static herr_t H5O_link_pre_copy_file(H5F_t *file_src, const H5O_msg_class_t *type,
void *mesg_src, hbool_t *deleted, const H5O_copy_t *cpy_info, void *udata);
static void *H5O_link_copy_file(H5F_t *file_src, void *native_src,
H5F_t *file_dst, hid_t dxpl_id, H5O_copy_t *cpy_info, void *udata);
static herr_t H5O_link_post_copy_file(const H5O_loc_t *parent_src_oloc, const void *mesg_src, H5O_loc_t *dst_oloc,
void *mesg_dst, hbool_t *modified, hid_t dxpl_id, H5O_copy_t *cpy_info);
static herr_t H5O_link_debug(H5F_t *f, hid_t dxpl_id, const void *_mesg,
FILE * stream, int indent, int fwidth);
/* This message derives from H5O message class */
const H5O_msg_class_t H5O_MSG_LINK[1] = {{
H5O_LINK_ID, /*message id number */
"link", /*message name for debugging */
sizeof(H5O_link_t), /*native message size */
H5O_link_decode, /*decode message */
H5O_link_encode, /*encode message */
H5O_link_copy, /*copy the native value */
H5O_link_size, /*size of symbol table entry */
H5O_link_reset, /* reset method */
H5O_link_free, /* free method */
H5O_link_delete, /* file delete method */
NULL, /* link method */
NULL, /*get share method */
NULL, /*set share method */
H5O_link_pre_copy_file, /* pre copy native value to file */
H5O_link_copy_file, /* copy native value to file */
H5O_link_post_copy_file, /* post copy native value to file */
H5O_link_debug /*debug the message */
}};
/* Current version of link information */
#define H5O_LINK_VERSION 1
#endif /* H5_GROUP_REVISION */
/* Declare a free list to manage the H5O_link_t struct */
H5FL_DEFINE_STATIC(H5O_link_t);
#ifdef H5_GROUP_REVISION
/*-------------------------------------------------------------------------
* Function: H5O_link_decode
*
* Purpose: Decode a message and return a pointer to
* a newly allocated one.
*
* Return: Success: Ptr to new message in native order.
*
* Failure: NULL
*
* Programmer: Quincey Koziol
* koziol@ncsa.uiuc.edu
* Aug 29 2005
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void *
H5O_link_decode(H5F_t *f, hid_t UNUSED dxpl_id, const uint8_t *p)
{
H5O_link_t *lnk = NULL; /* Pointer to link message */
uint16_t len; /* Length of a string in the message */
uint32_t tmp_time; /* Temporary copy of the time */
void *ret_value; /* Return value */
FUNC_ENTER_NOAPI_NOINIT(H5O_link_decode)
/* check args */
HDassert(f);
HDassert(p);
/* decode */
if(*p++ != H5O_LINK_VERSION)
HGOTO_ERROR(H5E_OHDR, H5E_CANTLOAD, NULL, "bad version number for message")
/* Allocate space for message */
if(NULL == (lnk = H5FL_CALLOC(H5O_link_t)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
/* Get the type of the link */
lnk->type = *p++;
if(lnk->type < H5L_LINK_HARD || lnk->type > H5L_LINK_MAX)
HGOTO_ERROR(H5E_OHDR, H5E_CANTLOAD, NULL, "bad link type")
/* Get the link creation time from the file */
UINT32DECODE(p, tmp_time)
lnk->ctime = (time_t)tmp_time;
/* Get the link name's character set */
lnk->cset = (H5T_cset_t)*p++;
if(lnk->cset < H5T_CSET_ASCII || lnk->cset > H5T_CSET_UTF8)
HGOTO_ERROR(H5E_OHDR, H5E_CANTLOAD, NULL, "bad cset type")
/* Get the link's name */
UINT16DECODE(p, len)
if(len == 0)
HGOTO_ERROR(H5E_OHDR, H5E_CANTLOAD, NULL, "invalid name length")
if(NULL == (lnk->name = H5MM_malloc((size_t)len + 1)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
HDmemcpy(lnk->name, p, len);
lnk->name[len] = '\0';
p += len;
/* Get the appropriate information for each type of link */
switch(lnk->type) {
case H5L_LINK_HARD:
/* Get the address of the object the link points to */
H5F_addr_decode(f, &p, &(lnk->u.hard.addr));
break;
case H5L_LINK_SOFT:
/* Get the link value */
UINT16DECODE(p, len)
if(len == 0)
HGOTO_ERROR(H5E_OHDR, H5E_CANTLOAD, NULL, "invalid link length")
if(NULL == (lnk->u.soft.name = H5MM_malloc((size_t)len + 1)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
HDmemcpy(lnk->u.soft.name, p, len);
lnk->u.soft.name[len] = '\0';
p += len;
break;
/* User-defined linkes */
default:
if(lnk->type < H5L_LINK_UD_MIN || lnk->type > H5L_LINK_MAX)
HGOTO_ERROR(H5E_OHDR, H5E_CANTLOAD, NULL, "unknown link type")
/* A UD link. Get the user-supplied data */
UINT16DECODE(p, len)
lnk->u.ud.size = len;
if(len > 0)
{
if(NULL == (lnk->u.ud.udata = H5MM_malloc((size_t)len)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
HDmemcpy(lnk->u.ud.udata, p, len);
p += len;
}
} /* end switch */
/* Set return value */
ret_value=lnk;
done:
if(ret_value == NULL)
if(lnk != NULL) {
if(lnk->name != NULL)
H5MM_xfree(lnk->name);
if(lnk->type == H5L_LINK_SOFT && lnk->u.soft.name != NULL)
H5MM_xfree(lnk->u.soft.name);
H5FL_FREE(H5O_link_t, lnk);
} /* end if */
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5O_link_decode() */
/*-------------------------------------------------------------------------
* Function: H5O_link_encode
*
* Purpose: Encodes a link message.
*
* Return: Non-negative on success/Negative on failure
*
* Programmer: Quincey Koziol
* koziol@ncsa.uiuc.edu
* Aug 29 2005
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static herr_t
H5O_link_encode(H5F_t *f, uint8_t *p, const void *_mesg)
{
const H5O_link_t *lnk = (const H5O_link_t *) _mesg;
uint16_t len; /* Length of a string in the message */
uint32_t tmp_time; /* Temporary copy of the time */
FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5O_link_encode)
/* check args */
HDassert(f);
HDassert(p);
HDassert(lnk);
/* encode */
*p++ = H5O_LINK_VERSION;
/* Store the type of the link */
*p++ = lnk->type;
/* Store the link creation time from the file */
tmp_time = lnk->ctime;
UINT32ENCODE(p, tmp_time)
/* Store the link name's character set */
*p++ = (uint8_t)lnk->cset;
/* Store the link's name */
len = (uint16_t)HDstrlen(lnk->name);
HDassert(len > 0);
UINT16ENCODE(p, len)
HDmemcpy(p, lnk->name, len);
p += len;
/* Store the appropriate information for each type of link */
switch(lnk->type) {
case H5L_LINK_HARD:
/* Store the address of the object the link points to */
H5F_addr_encode(f, &p, lnk->u.hard.addr);
break;
case H5L_LINK_SOFT:
/* Store the link value */
len = (uint16_t)HDstrlen(lnk->u.soft.name);
HDassert(len > 0);
UINT16ENCODE(p, len)
HDmemcpy(p, lnk->u.soft.name, len);
p += len;
break;
/* User-defined links */
default:
HDassert(lnk->type >= H5L_LINK_UD_MIN && lnk->type <= H5L_LINK_MAX);
/* Store the user-supplied data, however long it is */
len = (uint16_t)lnk->u.ud.size;
UINT16ENCODE(p, len)
if(len > 0)
{
HDmemcpy(p, lnk->u.ud.udata, len);
p+=len;
}
break;
} /* end switch */
FUNC_LEAVE_NOAPI(SUCCEED)
} /* end H5O_link_encode() */
#endif /* H5_GROUP_REVISION */
/*-------------------------------------------------------------------------
* Function: H5O_link_copy
*
* Purpose: Copies a message from _MESG to _DEST, allocating _DEST if
* necessary.
*
* Return: Success: Ptr to _DEST
*
* Failure: NULL
*
* Programmer: Quincey Koziol
* koziol@ncsa.uiuc.edu
* Aug 29 2005
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
void *
H5O_link_copy(const void *_mesg, void *_dest, unsigned UNUSED update_flags)
{
const H5O_link_t *lnk = (const H5O_link_t *) _mesg;
H5O_link_t *dest = (H5O_link_t *) _dest;
void *ret_value; /* Return value */
FUNC_ENTER_NOAPI_NOINIT(H5O_link_copy)
/* check args */
HDassert(lnk);
if(!dest && NULL == (dest = H5FL_MALLOC(H5O_link_t)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
/* copy */
*dest = *lnk;
HDassert(lnk->name);
dest->name = H5MM_xstrdup(lnk->name);
if(lnk->type == H5L_LINK_SOFT)
dest->u.soft.name = H5MM_xstrdup(lnk->u.soft.name);
else if(lnk->type >= H5L_LINK_UD_MIN) {
if(lnk->u.ud.size != 0)
{
if(NULL == (dest->u.ud.udata = H5MM_malloc(lnk->u.ud.size)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
HDmemcpy(dest->u.ud.udata, lnk->u.ud.udata, lnk->u.ud.size);
}
}/* end if */
/* Set return value */
ret_value=dest;
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5O_link_copy() */
#ifdef H5_GROUP_REVISION
/*-------------------------------------------------------------------------
* Function: H5O_link_size
*
* Purpose: Returns the size of the raw message in bytes not counting
* the message type or size fields, but only the data fields.
* This function doesn't take into account alignment.
*
* Return: Success: Message data size in bytes without alignment.
*
* Failure: zero
*
* Programmer: Quincey Koziol
* koziol@ncsa.uiuc.edu
* Aug 29 2005
*
*-------------------------------------------------------------------------
*/
static size_t
H5O_link_size(const H5F_t *f, const void *_mesg)
{
const H5O_link_t *lnk = (const H5O_link_t *)_mesg;
size_t ret_value; /* Return value */
FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5O_link_size)
/* Set return value */
ret_value = 1 + /* Version */
1 + /* Link type */
4 + /* Creation time */
1 + /* Character set */
2 + /* Name length */
HDstrlen(lnk->name); /* Name */
/* Add the appropriate length for each type of link */
switch(lnk->type) {
case H5L_LINK_HARD:
ret_value += H5F_SIZEOF_ADDR(f);
break;
case H5L_LINK_SOFT:
ret_value += 2 + /* Link value length */
HDstrlen(lnk->u.soft.name); /* Link value */
break;
default: /* Default is user-defined link type */
HDassert(lnk->type >= H5L_LINK_UD_MIN);
ret_value += 2 + /* User-defined data size */
lnk->u.ud.size; /* User-defined data */
break;
} /* end switch */
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5O_link_size() */
/*-------------------------------------------------------------------------
* Function: H5O_link_reset
*
* Purpose: Frees resources within a message, but doesn't free
* the message itself.
*
* Return: Non-negative on success/Negative on failure
*
* Programmer: Quincey Koziol
* Monday, August 29, 2005
*
*-------------------------------------------------------------------------
*/
static herr_t
H5O_link_reset(void *_mesg)
{
H5O_link_t *lnk = (H5O_link_t *)_mesg;
FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5O_link_reset)
if(lnk) {
/* Free information for link (but don't free link pointer) */
if(lnk->type == H5L_LINK_SOFT)
lnk->u.soft.name = H5MM_xfree(lnk->u.soft.name);
else if (lnk->type >= H5L_LINK_UD_MIN) {
if(lnk->u.ud.size > 0)
{
lnk->u.ud.udata = H5MM_xfree(lnk->u.ud.udata);
}
} /* end if */
lnk->name = H5MM_xfree(lnk->name);
} /* end if */
FUNC_LEAVE_NOAPI(SUCCEED)
} /* end H5O_link_reset() */
/*-------------------------------------------------------------------------
* Function: H5O_link_free
*
* Purpose: Free's the message contents and the message itself
*
* Return: Non-negative on success/Negative on failure
*
* Programmer: Quincey Koziol
* Monday, August 29, 2005
*
*-------------------------------------------------------------------------
*/
static herr_t
H5O_link_free(void *_mesg)
{
H5O_link_t *lnk = (H5O_link_t *)_mesg;
FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5O_link_free)
HDassert(lnk);
/* Free information for link */
H5O_link_reset(lnk);
H5FL_FREE(H5O_link_t, lnk);
FUNC_LEAVE_NOAPI(SUCCEED)
} /* end H5O_link_free() */
/*-------------------------------------------------------------------------
* Function: H5O_link_delete
*
* Purpose: Free file space referenced by message
*
* Return: Non-negative on success/Negative on failure
*
* Programmer: Quincey Koziol
* Monday, August 29, 2005
*
*-------------------------------------------------------------------------
*/
static herr_t
H5O_link_delete(H5F_t *f, hid_t dxpl_id, const void *_mesg, hbool_t adj_link)
{
const H5O_link_t *lnk = (const H5O_link_t *)_mesg;
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT(H5O_link_delete)
/* check args */
HDassert(f);
HDassert(lnk);
/* Decrement reference count to the object, for hard links */
if(lnk->type == H5L_LINK_HARD) {
H5O_loc_t oloc;
/* Construct object location for object, in order to decrement it's ref count */
H5O_loc_reset(&oloc);
oloc.file = f;
HDassert(H5F_addr_defined(lnk->u.hard.addr));
oloc.addr = lnk->u.hard.addr;
/* Decrement the ref count for the object, if requested */
if(adj_link)
if(H5O_link(&oloc, -1, dxpl_id)<0)
HGOTO_ERROR(H5E_OHDR, H5E_CANTFREE, FAIL, "unable to decrement object link count")
} /* end if */
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* end H5O_link_delete() */
/*-------------------------------------------------------------------------
* Function: H5O_link_pre_copy_file
*
* Purpose: Perform any necessary actions before copying message between
* files for link messages.
*
* Return: Success: Non-negative
*
* Failure: Negative
*
* Programmer: Quincey Koziol
* Monday, June 26, 2006
*
*-------------------------------------------------------------------------
*/
static herr_t
H5O_link_pre_copy_file(H5F_t UNUSED *file_src, const H5O_msg_class_t UNUSED *type,
void UNUSED *native_src, hbool_t *deleted, const H5O_copy_t *cpy_info,
void UNUSED *udata)
{
FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5O_link_pre_copy_file)
/* check args */
HDassert(deleted);
HDassert(cpy_info);
/* If we are performing a 'shallow hierarchy' copy, and this link won't
* be included in the final group, indicate that it should be deleted
* in the destination object header before performing any other actions
* on it.
*/
if(cpy_info->max_depth >= 0 && cpy_info->curr_depth >= cpy_info->max_depth)
*deleted = TRUE;
FUNC_LEAVE_NOAPI(SUCCEED)
} /* end H5O_link_pre_copy_file() */
/*-------------------------------------------------------------------------
* Function: H5O_link_copy_file
*
* Purpose: Copies a message from _MESG to _DEST in file
*
* Return: Success: Ptr to _DEST
*
* Failure: NULL
*
* Programmer: Quincey Koziol
* November 7, 2005
*
*-------------------------------------------------------------------------
*/
static void *
H5O_link_copy_file(H5F_t UNUSED *file_src, void *native_src, H5F_t UNUSED *file_dst,
hid_t UNUSED dxpl_id, H5O_copy_t UNUSED *cpy_info, void UNUSED *udata)
{
H5O_link_t *link_src = (H5O_link_t *) native_src;
H5O_link_t *link_dst = NULL;
void *ret_value; /* Return value */
FUNC_ENTER_NOAPI_NOINIT(H5O_link_copy_file)
/* check args */
HDassert(link_src);
HDassert(file_dst);
HDassert(cpy_info);
HDassert(cpy_info->max_depth < 0 || cpy_info->curr_depth < cpy_info->max_depth);
/* Allocate space for the destination stab */
if(NULL == (link_dst = H5FL_MALLOC(H5O_link_t)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
/* Copy top-level information */
*link_dst = *link_src;
/* Deep copy the link's name */
if(NULL == (link_dst->name = H5MM_xstrdup(link_src->name)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
/* "Deep copy" other information for each kind of link */
switch(link_src->type) {
case H5L_LINK_HARD:
/* Set link's address undefined here, will be fixed up in "post copy" callback */
link_dst->u.hard.addr = HADDR_UNDEF;
break;
case H5L_LINK_SOFT:
/* Copy the soft link's value */
if(NULL == (link_dst->u.soft.name = H5MM_xstrdup(link_src->u.soft.name)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
break;
default:
if(link_src->type >= H5L_LINK_UD_MIN)
{
/* Copy the user-defined link's user data */
if(link_src->u.ud.size != 0)
{
if(NULL == (link_dst->u.ud.udata = H5MM_malloc(link_src->u.ud.size)))
HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
HDmemcpy(link_dst->u.ud.udata, link_src->u.ud.udata, link_src->u.ud.size);
}
}
else
HGOTO_ERROR(H5E_SYM, H5E_BADVALUE, NULL, "unrecognized link type")
} /* end switch */
/* Set return value */
ret_value = link_dst;
done:
if(!ret_value)
if(link_dst)
H5FL_FREE(H5O_link_t, link_dst);
FUNC_LEAVE_NOAPI(ret_value)
} /* H5O_link_copy_file() */
/*-------------------------------------------------------------------------
* Function: H5O_link_post_copy_file
*
* Purpose: Finish copying a message from between files
*
* Return: Non-negative on success/Negative on failure
*
* Programmer: Quincey Koziol
* November 7, 2005
*
*-------------------------------------------------------------------------
*/
static herr_t
H5O_link_post_copy_file(const H5O_loc_t *parent_src_oloc, const void *mesg_src, H5O_loc_t *dst_oloc, void *mesg_dst,
hbool_t *modified, hid_t dxpl_id, H5O_copy_t *cpy_info)
{
H5O_link_t *link_src = (H5O_link_t *)mesg_src; /* Casting away const OK... -QAK */
H5O_link_t tmp_link_src;
H5O_link_t *link_dst = (H5O_link_t *)mesg_dst;
herr_t ret_value = SUCCEED; /* Return value */
FUNC_ENTER_NOAPI_NOINIT(H5O_link_post_copy_file)
/* check args */
HDassert(link_src);
HDassert(dst_oloc);
HDassert(H5F_addr_defined(dst_oloc->addr));
HDassert(dst_oloc->file);
HDassert(link_dst);
HDassert(modified && *modified == FALSE);
HDassert(cpy_info);
HDassert(cpy_info->max_depth < 0 || cpy_info->curr_depth < cpy_info->max_depth);
/* Expand soft link */
if(H5L_LINK_SOFT == link_src->type && cpy_info->expand_soft_link) {
H5G_stat_t statbuf; /* Information about object pointed to by soft link */
H5G_loc_t grp_loc; /* Group location for parent of soft link */
H5G_name_t grp_path; /* Path for parent of soft link */
/* Make a temporary copy, so that it will not change the info in the cache */
HDmemcpy(&tmp_link_src, link_src, sizeof(H5O_link_t));
link_src = &tmp_link_src;
/* Set up group location for soft link to start in */
H5G_name_reset(&grp_path);
grp_loc.path = &grp_path;
grp_loc.oloc = (H5O_loc_t *)parent_src_oloc; /* Casting away const OK... -QAK */
/* Check if the object pointed by the soft link exists in the source file */
/* (It would be more efficient to make a specialized traversal callback,
* but this is good enough for now... -QAK)
*/
if(H5G_get_objinfo(&grp_loc, link_src->u.soft.name, TRUE, &statbuf, H5AC_ind_dxpl_id) >= 0) {
/* Convert temp. copy of source soft link to hard link */
#if H5_SIZEOF_UINT64_T > H5_SIZEOF_LONG
link_src->u.hard.addr = (((haddr_t)statbuf.objno[1]) << (8 * sizeof(long))) | (haddr_t)statbuf.objno[0];
#else
link_src->u.hard.addr = statbuf.objno[0];
#endif
link_src->type = H5L_LINK_HARD;
/* Convert destination link to hard link */
link_dst->type = H5L_LINK_HARD;
link_dst->u.soft.name = H5MM_xfree(link_dst->u.soft.name);
} /* end if */
} /* if ((H5G_CACHED_SLINK == src_ent->type)... */
/* Additional "deep copy" for each kind of link */
switch(link_src->type) {
case H5L_LINK_HARD:
/* Copy the object pointed to */
{
H5O_loc_t src_oloc; /* Temporary object location for source object */
H5O_loc_t new_oloc; /* Temporary object location for source object */
/* Build temporary object location for source */
H5O_loc_reset(&src_oloc);
src_oloc.file = parent_src_oloc->file;
HDassert(H5F_addr_defined(link_src->u.hard.addr));
src_oloc.addr = link_src->u.hard.addr;
/* Build temporary object location for destination */
H5O_loc_reset(&new_oloc);
new_oloc.file = dst_oloc->file;
/* Copy the shared object from source to destination */
if(H5O_copy_header_map(&src_oloc, &new_oloc, dxpl_id, cpy_info, TRUE) < 0)
HGOTO_ERROR(H5E_OHDR, H5E_CANTCOPY, FAIL, "unable to copy object")
/* Update link information with new destination object's address */
link_dst->u.hard.addr = new_oloc.addr;
/* Indicate that the destination message was modified */
*modified = TRUE;
} /* end case */
break;
case H5L_LINK_SOFT:
case H5L_LINK_EXTERNAL:
HGOTO_DONE(SUCCEED)
break;
default:
HGOTO_ERROR(H5E_SYM, H5E_BADVALUE, FAIL, "unrecognized link type")
} /* end switch */
done:
FUNC_LEAVE_NOAPI(ret_value)
} /* H5O_link_post_copy_file() */
/*-------------------------------------------------------------------------
* Function: H5O_link_debug
*
* Purpose: Prints debugging info for a message.
*
* Return: Non-negative on success/Negative on failure
*
* Programmer: Quincey Koziol
* koziol@ncsa.uiuc.edu
* Aug 29 2005
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static herr_t
H5O_link_debug(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, const void *_mesg, FILE * stream,
int indent, int fwidth)
{
const H5O_link_t *lnk = (const H5O_link_t *) _mesg;
struct tm *tm;
char buf[128];
FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5O_link_debug)
/* check args */
HDassert(f);
HDassert(lnk);
HDassert(stream);
HDassert(indent >= 0);
HDassert(fwidth >= 0);
HDfprintf(stream, "%*s%-*s %s\n", indent, "", fwidth,
"Link Type:", (lnk->type == H5L_LINK_HARD ? "Hard" :
(lnk->type == H5L_LINK_SOFT ? "Soft" :
(lnk->type == H5L_LINK_EXTERNAL ? "External" :
(lnk->type >= H5L_LINK_UD_MIN ? "User-defined" : "Unknown")))));
tm = HDlocaltime(&(lnk->ctime));
HDstrftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S %Z", tm);
HDfprintf(stream, "%*s%-*s %s\n", indent, "", fwidth,
"Creation Time:", buf);
HDfprintf(stream, "%*s%-*s %s\n", indent, "", fwidth,
"Link Name Character Set:", (lnk->cset == H5T_CSET_ASCII ?
"ASCII" : (lnk->cset == H5T_CSET_UTF8 ? "UTF-8" : "Unknown")));
HDfprintf(stream, "%*s%-*s %s\n", indent, "", fwidth,
"Link Name:", lnk->name);
switch(lnk->type) {
case H5L_LINK_HARD:
HDfprintf(stream, "%*s%-*s %a\n", indent, "", fwidth,
"Object address:", lnk->u.hard.addr);
break;
case H5L_LINK_SOFT:
HDfprintf(stream, "%*s%-*s %s\n", indent, "", fwidth,
"Link Value:", lnk->u.soft.name);
break;
case H5L_LINK_EXTERNAL:
{
char * objname = (char *) lnk->u.ud.udata + (HDstrlen(lnk->u.ud.udata) + 1);
HDfprintf(stream, "%*s%-*s %s\n", indent, "", fwidth,
"Link File Name:", lnk->u.ud.udata);
HDfprintf(stream, "%*s%-*s %s\n", indent, "", fwidth,
"Link Object Name:", objname);
}
default:
break;
} /* end switch */
FUNC_LEAVE_NOAPI(SUCCEED)
} /* end H5O_link_debug() */
#endif /* H5_GROUP_REVISION */