F5X.c

Go to the documentation of this file.

#define _WIN32_WINNT  0x0501
 
 
#if defined(_WIN32)
 
#include <ws2tcpip.h>
#define USE_WINDOWS_SOCKETS
#define ioctl_socket(a, b, c)    ioctlsocket (a, b, (u_long *) (c))
 
#elif defined(_AIX)
 
#define _ALL_SOURCE
#define _XOPEN_SOURCE
#define _UNIX03
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <netdb.h>
#include <errno.h>
#include <unistd.h>
 
#define INVALID_SOCKET -1
#define WSAGetLastError() errno
#define closesocket(fd) close(fd)
#define ioctl_socket(a, b, c)    ioctl(a, b, c)
 
#else
 
#ifndef _POSIX_SOURCE
#define _POSIX_SOURCE
#endif
 
#include <netdb.h>
#include <netinet/in.h>
#include <errno.h>
#include <unistd.h>
 
#define INVALID_SOCKET -1
#define WSAGetLastError() errno
#define closesocket(fd) close(fd)
#define ioctl_socket(a, b, c)    ioctl(a, b, c)
 
#endif
 
#include <string.h>
 
#include "F5X.h"
#include "F5private.h"
#include "F5defs.h"
/*  erik commented --< */
/*  #if defined(__APPLE__) && defined(__MACH__) && defined(__POWERPC__) */
#include <stdlib.h>
/*  #else */
/*  #include <malloc.h> */
/*  #endif */
/*                 >-- */
#include <assert.h>
 
hid_t   F5Gappend(hid_t loc_id, const char *name)
{
        return F5Gappend_hinted_creation(loc_id, name, -1, -1);
}
 
 
hid_t   F5Gcreate(hid_t loc_id, const char *name,
                  int est_num_entries, int est_name_len ) 
{
hid_t   id;
hid_t   lcpl_id =    H5Pcreate(H5P_LINK_CREATE); 
        H5Pset_char_encoding(lcpl_id, H5T_CSET_UTF8); 
 
hid_t   gcpl_id = H5Pcreate( H5P_GROUP_CREATE ); 
 
        if (est_num_entries>=0 && est_name_len >=0)
        {
                H5Pset_est_link_info( gcpl_id, (unsigned) est_num_entries, (unsigned) est_name_len ); 
        } 
        H5Pset_link_creation_order( gcpl_id, H5P_CRT_ORDER_TRACKED | H5P_CRT_ORDER_INDEXED ); 
 
        id = H5Gcreate2(loc_id, name, lcpl_id, gcpl_id, H5P_DEFAULT); 
 
        H5Pclose( gcpl_id );
        H5Pclose( lcpl_id );
        return id;
}
 
hid_t   F5Gappend_hinted_creation(hid_t loc_id, const char *name,
                                  int est_num_entries, int est_name_len ) 
{
hid_t   id;
 
        F5printf(30, "F5Gappend(%lli,%s)", loc_id, name);
 
        H5E_BEGIN_TRY
        id = H5Gopen2(loc_id, name, H5P_DEFAULT );
        H5E_END_TRY
 
        if (id<0)
        {
                id = F5Gcreate(loc_id, name, est_num_entries, est_name_len );
                if (id<0)
                {
                        F5printf(0, "F5Gcreate(`%s') failed on ID %d!\n", name, (int)loc_id);
                }
        }
 
        if (id<0)
                F5printf(0, "F5Gappend(%lli,%s) FAILED", loc_id, name);
 
        return id;
}
 
hid_t   F5Gappend_tree(hid_t loc_id, const char *name)
{
char    *tree = strdup(name); 
char    *ptr = strtok(tree, "/"); 
hid_t   group_id = loc_id; 
        while(ptr)
        {
        hid_t   subgroup_id = F5Gappend(group_id, ptr); 
 
                F5printf(0, "F5Gappend_tree - %s", ptr);
                
                if (group_id != loc_id)
                        H5Gclose( group_id ); 
 
                group_id = subgroup_id;
                
                ptr = strtok(0, "/"); 
        } 
 
        free(tree); 
        return group_id;
}
 
hid_t   F5Gappend_external(hid_t loc_id, const char *name,
                           const char *target_file_name,
                           const char *target_obj_name,
                           const char *prefix )
{
herr_t  external_err;
hid_t   id; 
        H5E_BEGIN_TRY
        id = H5Gopen2(loc_id, name, H5P_DEFAULT); 
        H5E_END_TRY
        if (id>=0)
                return id; 
 
                
/* link creation property list used in creating the new link. */
/*
If crt_intermed_group is non-positive, the H5G_CRT_INTMD_GROUP, if present, will be removed from lcpl_id. Missing intermediate groups will not be created upon calls to functions such as those listed above that use lcpl_id. 
                  herr_t H5Pset_create_intermediate_group( hid_t lcpl_id, unsigned crt_intermed_group ) 
*/ 
hid_t   lcpl_id = H5Pcreate(H5P_LINK_CREATE); 
        H5Pset_char_encoding( lcpl_id, H5T_CSET_UTF8 );
 
/*
  herr_t H5Pset_elink_cb( hid_t lapl_id, H5L_elink_traverse_t func, void *op_data )
  Purpose:
  Sets the external link traversal callback function in a link access property list.
 
  herr_t H5Pset_elink_fapl( hid_t lapl_id, hid_t fapl_id )
  Purpose:
Sets a file access property list for use in accessing a file pointed to by an external link.          
*/ 
hid_t   lapl_id = H5Pcreate( H5P_LINK_ACCESS ); 
 
        if (prefix && *prefix)
                H5Pset_elink_prefix( lapl_id, prefix ); 
 
/*
  The library opens target file target_file_name with the file access property list that is set via H5Pset_elink_fapl when the external link link_name is accessed. If no such property list is set, the library uses the file access property list associated with the file of link_loc_id to open the target file.
*/ 
        external_err = H5Lcreate_external( target_file_name, target_obj_name,
                                           loc_id, name, lcpl_id, lapl_id ); 
        H5Pclose(lcpl_id);
        H5Pclose(lapl_id);
 
        H5E_BEGIN_TRY
        id = H5Gopen2(loc_id, name, H5P_DEFAULT); 
        H5E_END_TRY     
        if (id<0)
        {
        hid_t   ExternalFileID, ExternalFileGroup;
                F5printf(0, "F5Gappend_external(%lli,%s, target_file_name=%s,target_obj_name=%s,prefix=%s) INFO - No external file yet, thus- CREATING external file structure", loc_id, name,
                         target_file_name,
                         target_obj_name,
                         prefix ); 
                ExternalFileID = F5append( target_file_name ); 
                if (ExternalFileID<0)
                {
                        F5printf(0, "F5GappendExternal(%lli,%s, target_file_name=%s,target_obj_name=%s,prefix=%s) FAILED CREATING external file", loc_id, name,
                                 target_file_name,
                                 target_obj_name,
                                 prefix ); 
                }
 
                ExternalFileGroup = F5Gappend_tree(ExternalFileID, target_obj_name); 
 
                if (ExternalFileGroup<0)
                {
                        F5printf(0, "F5GappendExternal(%lli,%s, target_file_name=%s,target_obj_name=%s,prefix=%s) FAILED CREATING external file group", loc_id, name,
                                 target_file_name,
                                 target_obj_name,
                                 prefix ); 
                }
                
                H5Gclose( ExternalFileGroup );
                H5Fclose( ExternalFileID );
 
                id = H5Gopen2(loc_id, name, H5P_DEFAULT);
                if (id<0)
                {
                        F5printf(0, "F5GappendExternal(%lli,%s, target_file_name=%s,target_obj_name=%s,prefix=%s) FAILED CREATING external file structure", loc_id, name,
                                 target_file_name,
                                 target_obj_name,
                                 prefix ); 
                }
        }
 
        return id;
}
 
hid_t   F5append(const char *filename )
{
hid_t   id;
 
        H5E_BEGIN_TRY
        id = H5Fcreate (filename, H5F_ACC_EXCL, H5P_DEFAULT, H5P_DEFAULT);
        H5E_END_TRY
 
        if (id<0)
                return H5Fopen(filename, H5F_ACC_RDWR, H5P_DEFAULT);
 
        return id;
}
 
hid_t F5Dappend(hid_t loc_id, const char *name, hid_t type_id, hid_t space_id, hid_t create_plist_id )
{
hid_t   id;
 
        H5E_BEGIN_TRY
        id = H5Dopen2(loc_id, name, H5P_DEFAULT );
        H5E_END_TRY
 
        if (id>0)
        {
        hid_t   FileSpace_id = H5Dget_space( id ); 
        hssize_t NewPoints = H5Sget_simple_extent_npoints( space_id );
        hssize_t OldPoints = H5Sget_simple_extent_npoints( FileSpace_id );
                F5printf(41, "F5Dappend(%lli,%s,...) opening existing dataset...", loc_id, name); 
                H5Sclose( FileSpace_id ); 
 
                if (NewPoints != OldPoints)
                {
                hid_t lapl_id = H5P_DEFAULT;
                        
                        F5printf(0, "PERFORMANCE WARNING: F5Dappend(,%s,,NewSize=%lld,...) modifying dataset to different size, it is %lld currently (%s to %u%%).",
                                 name, (long long)NewPoints,  (long long)OldPoints,
                                 (NewPoints<OldPoints)?"shrink":"grow", (int)(100*NewPoints)/OldPoints ); 
                        H5Dclose(id); 
                        id = -1; 
                        H5Ldelete( loc_id, name, lapl_id );
                }
        }
 
        if (id<0)
        {
                F5printf(41, "F5Dappend(%lli,%s,...) could not open existing dataset...", loc_id, name); 
                id = H5Dcreate2(loc_id, name, type_id, space_id, H5P_DEFAULT, create_plist_id, H5P_DEFAULT) ;
                if (id<0)
                        F5printf(41, "F5Dappend(%lli,%s,...) could not create dataset...", loc_id, name);
        }
        return id;
}
 
hid_t   F5Dcreate(hid_t loc_id, const char *name, hid_t type_id, hid_t space_id, hid_t create_plist_id )
{
hid_t   id;
        H5E_BEGIN_TRY 
        id = H5Dcreate2(loc_id, name, type_id, space_id, H5P_DEFAULT, create_plist_id, H5P_DEFAULT) ;
        H5E_END_TRY
        if (id<0)
        {
                F5printf(10, "F5Dcreate(%d,%s,...) could not create dataset, dataset already exists, deleting it...", (int)(loc_id), name);
                H5Ldelete( loc_id, name, H5P_DEFAULT );
                id = H5Dcreate2(loc_id, name, type_id, space_id, H5P_DEFAULT, create_plist_id, H5P_DEFAULT);
        }
 
        if (id<0)
                F5printf(0, "F5Dcreate(%d,%s,...) could not create dataset, not even after deletion...", (int)(loc_id), name); 
 
        return id; 
}
 
hid_t   F5Gtry_to_open(hid_t location, const char*name)
{
hid_t   retval;
        H5E_BEGIN_TRY
        retval = H5Gopen2(location, name, H5P_DEFAULT);
        H5E_END_TRY
 
        return retval;
}
 
int     F5Gexist(hid_t location, const char*name)
{
hid_t   retval;
 
        H5E_BEGIN_TRY
        retval = H5Gopen2(location, name, H5P_DEFAULT);
        H5E_END_TRY
 
        if (retval>=0)
                H5Gclose(retval);
 
        return retval>=0;
}
 
int     F5Dexist(hid_t location, const char*name)
{
hid_t   retval;
 
        H5E_BEGIN_TRY
        retval = H5Dopen2(location, name, H5P_DEFAULT);
        H5E_END_TRY
 
        if (retval>=0)
                H5Dclose(retval);
 
        return retval>=0;
}
 
hid_t F5Dtry_to_open(hid_t location, const char*name)
{
hid_t   retval;
 
        H5E_BEGIN_TRY
        retval = H5Dopen2(location, name, H5P_DEFAULT);
        H5E_END_TRY
 
        return retval;
}
 
 
herr_t F5Xclose(hid_t obj_id /*, H5I_type_t* pret_type_id */)
{
        /* Get the type */
        H5I_type_t ObjectType = H5Iget_type(obj_id);
 
        /* Return it to the caller, if wanted
        if (pret_type_id)
                (*pret_type_id) = ObjectType;           */
 
        /* Call the appropriate closing func */
        switch (ObjectType)
        {
                case H5I_FILE:
                        return H5Fclose(obj_id);
 
                case H5I_GROUP:
                        return H5Gclose(obj_id);
 
                case H5I_DATATYPE:
                        return H5Tclose(obj_id);
 
                case H5I_DATASPACE:
                        return H5Sclose(obj_id);
 
                case H5I_DATASET:
                        return H5Dclose(obj_id);
 
                case H5I_ATTR:
                        return H5Aclose(obj_id);
 
                case H5I_BADID:
                        return -1;
 
                default:
            printf ("INTERNAL ERROR F5Xclose(): unknown type %d\n", ObjectType);
            return -1;
        }
}
 
 
 
/*******************************************************************************/
 
void F5socket_init()
{
#if defined(_WINDOWS)
WSADATA wsaData;
WORD    wVersionRequested = MAKEWORD( 2, 2 );
int     err = WSAStartup( wVersionRequested, &wsaData );
        switch(err)
        {
        case 0:
                break;
 
        default:
                puts("windows sockets error");
                break;
        }
#endif
}
 
void F5socket_cleanup()
{
#if defined(_WINDOWS)
        WSACleanup( );
#endif
}
 
int     F5connect(const char*url)
{
#ifndef NI_MAXHOST
#define NI_MAXHOST 10000
#endif
 
char hostname[NI_MAXHOST];
char    *p, *command;
 
const char*service = "6666";
int     sockfd = 0;
struct  addrinfo *res;
struct  addrinfo *r;
int     error;
int     commandlen = 0;
 
        /*
          URL chopping: get hostname and service name
        */
        if ( strncmp( url, "hdf5://", 7 ) != 0
             &&
             strncmp( url, "HDF5://", 7 ) != 0 )
        {
                return 0;
        }
        url += 7;
 
        strcpy(hostname, url);
        p = strchr(hostname,':');
        if (p)
        {
                *p = '\0';
                p++;
                service = p;
        }
 
        command = strchr(p?p:hostname,'/');
        if (command)
        {
                *command++ = '\0';
                commandlen = strlen(command);
        }
 
 
/***************************************/
        error = getaddrinfo(hostname, service, NULL, &res);
        switch(error)
        {
        case EAI_AGAIN: /* case WSATRY_AGAIN:    */
                printf("CANNOT open HDF5 stream from `%s' %s: "
                       "A temporary failure in name resolution occurred.\n", hostname, service);
                return -1;
 
        case EAI_BADFLAGS:/*    WSAEINVAL */
                printf("CANNOT open HDF5 stream from `%s' %s: "
                       "An invalid value was provided for the ai_flags member of the hints parameter.\n",
                       hostname, service);
                return -1;
 
        case EAI_FAIL:/*        WSANO_RECOVERY  */
                printf("CANNOT open HDF5 stream from `%s' %s:"
                       " A nonrecoverable failure in name resolution occurred.\n",
                       hostname, service);
                return -1;
 
/*
EAI_FAMILY      WSAEAFNOSUPPORT         The ai_family member of the hints parameter is not supported.
EAI_MEMORY      WSA_NOT_ENOUGH_MEMORY   A memory allocation failure occurred.
*/
        case EAI_NONAME:  /*   WSAHOST_NOT_FOUND  */
                printf("CANNOT open HDF5 stream from `%s' %s: "
                       "The name does not resolve for the supplied parameters "
                       "or the nodename and servname parameters were not provided.\n", hostname, service);
                return -1;
 
        case EAI_SERVICE: /*    WSATYPE_NOT_FOUND */
                printf("CANNOT open HDF5 stream from `%s' %s: "
                       "The servname parameter is not supported for the specified "
                       "ai_socktype member of the hints parameter.\n", hostname, service);
                return -1;
 
/*EAI_SOCKTYPE  WSAESOCKTNOSUPPORT      The ai_socktype member of the hints parameter is not supported. */
 
        default:
                printf("CANNOT open HDF5 stream from `%s' %s: error code %d\n", hostname, service, error);
                return -1;
 
        case 0: /* no error */
                F5printf(10, "HDF5 stream to `%s' %s: addrinfo ok, proceeding\n", hostname, service);
                break;
        }
 
 
        for(r = res; r; r = r->ai_next)
        {
        int     cerror;
                sockfd = socket(r->ai_family,
                                r->ai_socktype,
                                r->ai_protocol);
 
                if (sockfd <= 0 || sockfd==(int)INVALID_SOCKET)
                {
                        printf("HDF5 stream: FAILED to open connection\n");
                        continue;
                }
 
                F5printf(5, "F5connect: Created socket for HDF5 stream from `%s':%s...\n", hostname, service );
 
                cerror = connect(sockfd, r->ai_addr, r->ai_addrlen);
                F5printf(5, "F5connect: Connected to `%s':%s...\n", hostname, service );
                if (cerror)
                {
                        cerror = WSAGetLastError();
                        switch( cerror )
                        {
#if defined(_WINDOWS)
                        case WSAECONNREFUSED:
#else
                        case ECONNREFUSED:
#endif
                                printf("HDF5 stream to `%s' %s: connection refused.\n", hostname, service);
                                break;
/*
//                              case WSAEADDRNOTAVAIL:
//                                      printf("HDF5 stream to `%s' %s: The remote address is not a valid address.\n", hostname, service);
//                                      break;
 
//                              case WSAEFAULT:
//                              case WSAENETUNREACH:
//                              case WSAEHOSTUNREACH:
//                              printf("HDF5 stream to `%s' %s: A socket operation was attempted to an unreachable host.\n", hostname, service);
//                                      break;
*/
                        default:
                                perror("CANNOT connect to HDF5 stream");
                                printf("HDF5 stream to `%s' %s: error code %d.\n", hostname, service, cerror);
                                continue;
                        }
                        closesocket( sockfd );
                        sockfd = 0;
                        continue;
                }
                break;
        }
        freeaddrinfo(res);
 
        if (sockfd<=0)
        {
                puts("HDF5 URL: could not open valid connection.");
                return -1;
        }
 
        if (commandlen>0)
        {
        int     werr;
                F5printf(1, "Sending HDF5 Request `%s'\n", command );
 
                werr = send(sockfd, command, commandlen, 0);
                if (werr<0)
                        perror("Sending HDF5 Request");
                else if (werr != commandlen)
                        F5printf(1,"Warning: Only sent %d of %d bytes during HDF5 Request transfer\n", werr, commandlen);
        }
        return sockfd;
}
 
 
void F5closesocket(int socket)
{
        if (socket>0)
                closesocket(socket);
}
 
 
hid_t F5open(const char *filename, int socket )
{
#ifdef  H5_HAVE_STREAM
hid_t   proplist = H5Pcreate (H5P_FILE_ACCESS);
hid_t   file_id;
 
H5FD_stream_fapl_t fapl;
        fapl.increment = 1024*1024;
        fapl.do_socket_io = 1;
        fapl.socket = socket;
        fapl.backlog = 0;
        fapl.broadcast_fn = 0;
        if (socket>0)
        {
                if (H5Pset_fapl_stream ( proplist, &fapl)<0)
                {
                        puts("HDF5: Problem in H5Pset_fapl_stream ()!");
                }
                file_id = H5Fopen("/dev/null", H5F_ACC_RDONLY, proplist);
                H5Pclose (proplist);
                if (file_id<0)
                {
                        puts("Problem Receiving HDF5 Stream Data...");
                        return -1;
                }
                return file_id;
        }
#endif
        return H5Fopen(filename, H5F_ACC_RDONLY, H5P_DEFAULT);
}
 
 
int     F5listen(const char *service)
{
struct addrinfo hints, *res, *ressave;
int     n, sockfd = -1;
 
        memset(&hints, 0, sizeof(struct addrinfo));
 
        /*
          AI_PASSIVE flag: the resulting address is used to bind
          to a socket for accepting incoming connections.
          So, when the hostname==NULL, getaddrinfo function will
          return one entry per allowed protocol family containing
          the unspecified address for that family.
        */
        hints.ai_flags    = AI_PASSIVE; 
        hints.ai_family   = AF_INET;
        hints.ai_socktype = SOCK_STREAM;
        hints.ai_protocol = IPPROTO_TCP;
 
        n = getaddrinfo( NULL, service, &hints, &res);
 
        if (n<0)
        {
                return n;
        }
 
        ressave = res;
 
        /*
          Try open socket with each address getaddrinfo returned,
          until getting a valid listening socket.
        */
        while (res)
        {
                sockfd = socket(res->ai_family,
                                res->ai_socktype,
                                res->ai_protocol);
 
                if (!(sockfd < 0))
                {
                        if (bind(sockfd, res->ai_addr, res->ai_addrlen) == 0)
                                break;
 
                        closesocket(sockfd);
                        sockfd=-1;
                }
                res = res->ai_next;
        }
 
        if (sockfd < 0)
        {
                freeaddrinfo(ressave);
                F5printf(1, "F5listen(): could not open socket\n");
                return -1;
        }
 
 
        {
        struct linger wait_on_close;
                wait_on_close.l_onoff = 1; /* yes, wait on close */
                wait_on_close.l_linger = 1; /* and wait for 1 second */
                setsockopt (sockfd, SOL_SOCKET, SO_LINGER,
                            (const char*)&wait_on_close, sizeof (wait_on_close));
/*
// Erik says: the variables "on" and "port" are undeclared
//#ifdef        SO_REUSEPORT
//              if (setsockopt (sockfd, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(int)) < 0)
//              {
//                      printf("Couldn't set SO_REUSEPORT to port %u: %s",
//                             port, strerror (errno));
//                      closesocket (sockfd);
//                      return -1;
//              }
//#endif
*/
        }
 
        listen(sockfd, SOMAXCONN);
 
        freeaddrinfo(ressave);
 
        return sockfd;
}