enhanced HOMER reader to work on normal buffer
[u/mrichter/AliRoot.git] / HLT / BASE / HOMER / AliHLTHOMERReader.cxx
1 /************************************************************************
2 **
3 **
4 ** This file is property of and copyright by the Technical Computer
5 ** Science Group, Kirchhoff Institute for Physics, Ruprecht-Karls-
6 ** University, Heidelberg, Germany, 2001
7 ** This file has been written by Timm Morten Steinbeck, 
8 ** timm@kip.uni-heidelberg.de
9 **
10 **
11 ** See the file license.txt for details regarding usage, modification,
12 ** distribution and warranty.
13 ** Important: This file is provided without any warranty, including
14 ** fitness for any particular purpose.
15 **
16 **
17 ** Newer versions of this file's package will be made available from 
18 ** http://web.kip.uni-heidelberg.de/Hardwinf/L3/ 
19 ** or the corresponding page of the Heidelberg Alice Level 3 group.
20 **
21 *************************************************************************/
22
23 /*
24 ***************************************************************************
25 **
26 ** $Author$ - Initial Version by Timm Morten Steinbeck
27 **
28 ** $Id$ 
29 **
30 ***************************************************************************
31 */
32
33 /** @file   AliHLTHOMERReader.cxx
34     @author Timm Steinbeck
35     @date   Sep 14 2007
36     @brief  HLT Online Monitoring Environment including ROOT - Reader
37     @note   migrated from PubSub HLT-stable-20070905.141318 (rev 2375)    */
38
39 // see header file for class documentation
40 // or
41 // refer to README to build package
42 // or
43 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
44
45 #include "AliHLTHOMERReader.h"
46 #include <stdio.h>
47 #include <string.h>
48 #include <errno.h>
49 #include <netdb.h>
50 extern int h_errno;
51 #include <sys/types.h>
52 #include <sys/socket.h>
53 #include <netinet/in.h>
54 #include <netinet/tcp.h>
55 #include <unistd.h>
56 #include <rpc/types.h>
57 #include <fcntl.h>
58 #include <sys/stat.h>
59 #include <netinet/in.h>
60 #include <arpa/inet.h>
61 #ifdef USE_ROOT
62 #include <Rtypes.h>
63 #endif
64
65
66 #define MOD_BIN "MOD BIN\n"
67 #define MOD_ASC "MOD ASC\n"
68 #define GET_ONE "GET ONE\n"
69 #define GET_ALL "GET ALL\n"
70
71 #ifdef USE_ROOT
72 ClassImp(AliHLTMonitoringReader);
73 ClassImp(AliHLTHOMERReader);
74 #endif
75
76
77
78
79
80 #ifdef USE_ROOT
81 AliHLTHOMERReader::AliHLTHOMERReader()
82   :
83   fCurrentEventType(~(homer_uint64)0),
84   fCurrentEventID(~(homer_uint64)0),
85   fBlockCnt(0),
86   fMaxBlockCnt(0),
87   fBlocks(NULL),
88   fDataSourceCnt(0),
89   fTCPDataSourceCnt(0),
90   fShmDataSourceCnt(0),
91   fDataSourceMaxCnt(0),
92   fDataSources(NULL),
93   fConnectionStatus(0),
94   fErrorConnection(~(unsigned int)0),
95   fEventRequestAdvanceTime(0)
96     {
97 // Reader implementation of the HOMER interface.
98 // The HLT Monitoring Environment including ROOT is
99 // a native interface to ship out data from the HLT chain.
100 // See pdf document shiped with the package
101 // for class documentation and tutorial.
102     Init();
103     }
104 #endif
105
106
107 AliHLTHOMERReader::AliHLTHOMERReader( const char* hostname, unsigned short port )
108   :
109   AliHLTMonitoringReader(),
110   fCurrentEventType(~(homer_uint64)0),
111   fCurrentEventID(~(homer_uint64)0),
112   fBlockCnt(0),
113   fMaxBlockCnt(0),
114   fBlocks(NULL),
115   fDataSourceCnt(0),
116   fTCPDataSourceCnt(0),
117   fShmDataSourceCnt(0),
118   fDataSourceMaxCnt(0),
119   fDataSources(NULL),
120   fConnectionStatus(0),
121   fErrorConnection(~(unsigned int)0),
122   fEventRequestAdvanceTime(0)
123     {
124 // see header file for class documentation
125 // For reading from a TCP port
126     Init();
127     if ( !AllocDataSources(1) )
128         {
129         fErrorConnection = 0;
130         fConnectionStatus = ENOMEM;
131         return;
132         }
133     fConnectionStatus = AddDataSource( hostname, port, fDataSources[0] );
134     if ( fConnectionStatus )
135         fErrorConnection = 0;
136     else
137         {
138         fDataSourceCnt++;
139         fTCPDataSourceCnt++;
140         fDataSources[0].fNdx = 0;
141         }
142     }
143
144 AliHLTHOMERReader::AliHLTHOMERReader( unsigned int tcpCnt, const char** hostnames, unsigned short* ports )
145   :
146   AliHLTMonitoringReader(),
147   fCurrentEventType(~(homer_uint64)0),
148   fCurrentEventID(~(homer_uint64)0),
149   fBlockCnt(0),
150   fMaxBlockCnt(0),
151   fBlocks(NULL),
152   fDataSourceCnt(0),
153   fTCPDataSourceCnt(0),
154   fShmDataSourceCnt(0),
155   fDataSourceMaxCnt(0),
156   fDataSources(NULL),
157   fConnectionStatus(0),
158   fErrorConnection(~(unsigned int)0),
159   fEventRequestAdvanceTime(0)
160     {
161 // see header file for class documentation
162 // For reading from multiple TCP ports
163     Init();
164     if ( !AllocDataSources(tcpCnt) )
165         {
166         fErrorConnection = 0;
167         fConnectionStatus = ENOMEM;
168         return;
169         }
170     for ( unsigned int n = 0; n < tcpCnt; n++, fDataSourceCnt++, fTCPDataSourceCnt++ )
171         {
172         fConnectionStatus = AddDataSource( hostnames[n], ports[n], fDataSources[n] );
173         if ( fConnectionStatus )
174             {
175             fErrorConnection = n;
176             return;
177             }
178         fDataSources[n].fNdx = n;
179         }
180     }
181
182 AliHLTHOMERReader::AliHLTHOMERReader( key_t shmKey, int shmSize )
183   :
184   AliHLTMonitoringReader(),
185   fCurrentEventType(~(homer_uint64)0),
186   fCurrentEventID(~(homer_uint64)0),
187   fBlockCnt(0),
188   fMaxBlockCnt(0),
189   fBlocks(NULL),
190   fDataSourceCnt(0),
191   fTCPDataSourceCnt(0),
192   fShmDataSourceCnt(0),
193   fDataSourceMaxCnt(0),
194   fDataSources(NULL),
195   fConnectionStatus(0),
196   fErrorConnection(~(unsigned int)0),
197   fEventRequestAdvanceTime(0)
198     {
199 // see header file for class documentation
200 // For reading from a System V shared memory segment
201     Init();
202     if ( !AllocDataSources(1) )
203         {
204         fErrorConnection = 0;
205         fConnectionStatus = ENOMEM;
206         return;
207         }
208     fConnectionStatus = AddDataSource( shmKey, shmSize, fDataSources[0] );
209     if ( fConnectionStatus )
210         fErrorConnection = 0;
211     else
212         {
213         fDataSourceCnt++;
214         fShmDataSourceCnt++;
215         fDataSources[0].fNdx = 0;
216         }
217     }
218
219 AliHLTHOMERReader::AliHLTHOMERReader( unsigned int shmCnt, key_t* shmKeys, int* shmSizes )
220   :
221   AliHLTMonitoringReader(),
222   fCurrentEventType(~(homer_uint64)0),
223   fCurrentEventID(~(homer_uint64)0),
224   fBlockCnt(0),
225   fMaxBlockCnt(0),
226   fBlocks(NULL),
227   fDataSourceCnt(0),
228   fTCPDataSourceCnt(0),
229   fShmDataSourceCnt(0),
230   fDataSourceMaxCnt(0),
231   fDataSources(NULL),
232   fConnectionStatus(0),
233   fErrorConnection(~(unsigned int)0),
234   fEventRequestAdvanceTime(0)
235     {
236 // see header file for class documentation
237 // For reading from multiple System V shared memory segments
238     Init();
239     if ( !AllocDataSources(shmCnt) )
240         {
241         fErrorConnection = 0;
242         fConnectionStatus = ENOMEM;
243         return;
244         }
245     for ( unsigned int n = 0; n < shmCnt; n++, fDataSourceCnt++, fShmDataSourceCnt++ )
246         {
247         fConnectionStatus = AddDataSource( shmKeys[n], shmSizes[n], fDataSources[n] );
248         if ( fConnectionStatus )
249             {
250             fErrorConnection = n;
251             return;
252             }
253         fDataSources[n].fNdx = n;
254         }
255     }
256
257 AliHLTHOMERReader::AliHLTHOMERReader( unsigned int tcpCnt, const char** hostnames, unsigned short* ports, 
258                           unsigned int shmCnt, key_t* shmKeys, int* shmSizes )
259   :
260   AliHLTMonitoringReader(),
261   fCurrentEventType(~(homer_uint64)0),
262   fCurrentEventID(~(homer_uint64)0),
263   fBlockCnt(0),
264   fMaxBlockCnt(0),
265   fBlocks(NULL),
266   fDataSourceCnt(0),
267   fTCPDataSourceCnt(0),
268   fShmDataSourceCnt(0),
269   fDataSourceMaxCnt(0),
270   fDataSources(NULL),
271   fConnectionStatus(0),
272   fErrorConnection(~(unsigned int)0),
273   fEventRequestAdvanceTime(0)
274     {
275 // see header file for class documentation
276 // For reading from multiple TCP ports and multiple System V shared memory segments
277     Init();
278     if ( !AllocDataSources(tcpCnt+shmCnt) )
279         {
280         fErrorConnection = 0;
281         fConnectionStatus = ENOMEM;
282         return;
283         }
284     for ( unsigned int n = 0; n < tcpCnt; n++, fDataSourceCnt++, fTCPDataSourceCnt++ )
285         {
286         fConnectionStatus = AddDataSource( hostnames[n], ports[n], fDataSources[n] );
287         if ( fConnectionStatus )
288             {
289             fErrorConnection = n;
290             return;
291             }
292         fDataSources[n].fNdx = n;
293         }
294     for ( unsigned int n = 0; n < shmCnt; n++, fDataSourceCnt++, fShmDataSourceCnt++ )
295         {
296         fConnectionStatus = AddDataSource( shmKeys[n], shmSizes[n], fDataSources[tcpCnt+n] );
297         if ( fConnectionStatus )
298             {
299             fErrorConnection = tcpCnt+n;
300             return;
301             }
302         fDataSources[n].fNdx = n;
303         }
304     }
305
306 AliHLTHOMERReader::AliHLTHOMERReader( const void* pBuffer, int size )
307   :
308   AliHLTMonitoringReader(),
309   fCurrentEventType(~(homer_uint64)0),
310   fCurrentEventID(~(homer_uint64)0),
311   fBlockCnt(0),
312   fMaxBlockCnt(0),
313   fBlocks(NULL),
314   fDataSourceCnt(0),
315   fTCPDataSourceCnt(0),
316   fShmDataSourceCnt(0),
317   fDataSourceMaxCnt(0),
318   fDataSources(NULL),
319   fConnectionStatus(0),
320   fErrorConnection(~(unsigned int)0),
321   fEventRequestAdvanceTime(0)
322     {
323 // see header file for class documentation
324 // For reading from a System V shared memory segment
325     Init();
326     if ( !AllocDataSources(1) )
327         {
328         fErrorConnection = 0;
329         fConnectionStatus = ENOMEM;
330         return;
331         }
332     //fConnectionStatus = AddDataSource( shmKey, shmSize, fDataSources[0] );
333     if ( fConnectionStatus )
334         fErrorConnection = 0;
335     else
336         {
337         fDataSourceCnt++;
338         fShmDataSourceCnt++;
339         fDataSources[0].fNdx = 0;
340         }
341     }
342
343 AliHLTHOMERReader::~AliHLTHOMERReader()
344     {
345 // see header file for class documentation
346     ReleaseCurrentEvent();
347     FreeDataSources();
348     }
349
350 int  AliHLTHOMERReader::ReadNextEvent()
351     {
352 // see header file for class documentation
353 // Read in the next available event
354     return ReadNextEvent( false, 0 );
355     }
356
357 int AliHLTHOMERReader::ReadNextEvent( unsigned long timeout )
358     {
359 // see header file for class documentation
360 // Read in the next available event
361     return ReadNextEvent( true, timeout );
362     }
363
364 unsigned long AliHLTHOMERReader::GetBlockDataLength( unsigned long ndx ) const
365     {
366 // see header file for class documentation
367 // Return the size (in bytes) of the current event's data
368 // block with the given block index (starting at 0).
369     if ( ndx >= fBlockCnt )
370         return 0;
371     return fBlocks[ndx].fLength;
372     }
373
374 const void* AliHLTHOMERReader::GetBlockData( unsigned long ndx ) const
375     {
376 // see header file for class documentation
377 // Return a pointer to the start of the current event's data
378 // block with the given block index (starting at 0).
379     if ( ndx >= fBlockCnt )
380         return NULL;
381     return fBlocks[ndx].fData;
382     }
383
384 const char* AliHLTHOMERReader::GetBlockSendNodeID( unsigned long ndx ) const
385     {
386 // see header file for class documentation
387 // Return IP address or hostname of node which sent the 
388 // current event's data block with the given block index 
389 // (starting at 0).
390 // For HOMER this is the ID of the node on which the subscriber 
391 // that provided this data runs/ran.
392     if ( ndx >= fBlockCnt )
393         return NULL;
394 #ifdef DEBUG
395     if ( fBlocks[ndx].fSource >= fDataSourceCnt )
396         {
397         fprintf( stderr, "%s:%d: Internal Error: fBlocks[ndx].fSource (%lu) >= fDataSourceCnt (%lu)\n",
398                  __FILE__, __LINE__, fBlocks[ndx].fSource, fDataSourceCnt );
399         return NULL;
400         }
401 #endif
402     return fDataSources[ fBlocks[ndx].fSource ].fHostname;
403     //return fBlocks[ndx].fOriginatingNodeID;
404     }
405
406 homer_uint8 AliHLTHOMERReader::GetBlockByteOrder( unsigned long ndx ) const
407     {
408 // see header file for class documentation
409 // Return byte order of the data stored in the 
410 // current event's data block with the given block index (starting at 0). 
411 //         0 is unknown alignment, 
412 //         1 ist little endian, 
413 //         2 is big endian. */
414     if ( ndx >= fBlockCnt )
415         return 0;
416     //return ((AliHLTRIBlockDescriptorV1*)fBlocks[ndx].fMetaData)->fType.fID;
417     return *(((homer_uint8*)fBlocks[ndx].fMetaData)+kByteOrderAttribute_8b_Offset);
418     }
419
420 homer_uint8 AliHLTHOMERReader::GetBlockTypeAlignment( unsigned long ndx, homer_uint8 dataType ) const
421     {
422 // see header file for class documentation
423 // Return the alignment (in bytes) of the given datatype 
424 // in the data stored in the current event's data block
425 // with the given block index (starting at 0). 
426 // Possible values for the data type are
427 //         0: homer_uint64
428 //         1: homer_uint32
429 //         2: uin16
430 //         3: homer_uint8
431 //         4: double
432 //         5: float
433     if ( ndx >= fBlockCnt )
434         return 0;
435     if ( dataType > (kFloatAlignment_8b_Offset-kAlignment_8b_StartOffset) )
436         return 0;
437     //return ((AliHLTRIBlockDescriptorV1*)fBlocks[ndx].fMetaData)->fType.fID;
438     return *(((homer_uint8*)fBlocks[ndx].fMetaData)+kAlignment_8b_StartOffset+dataType);
439     }
440
441 homer_uint64 AliHLTHOMERReader::GetBlockStatusFlags( unsigned long ndx ) const
442     {
443 // see header file for class documentation
444     if ( ndx >= fBlockCnt )
445         return 0;
446     return *(((homer_uint64*)fBlocks[ndx].fMetaData)+kStatusFlags_64b_Offset);
447     }
448
449 /* HOMER specific */
450 /* Return the type of the data in the current event's data
451    block with the given block index (starting at 0). */
452 homer_uint64 AliHLTHOMERReader::GetBlockDataType( unsigned long ndx ) const
453     {
454 // see header file for class documentation
455     if ( ndx >= fBlockCnt )
456         return ~(homer_uint64)0;
457     //return ((AliHLTRIBlockDescriptorV1*)fBlocks[ndx].fMetaData)->fType.fID;
458     return *(((homer_uint64*)fBlocks[ndx].fMetaData)+kType_64b_Offset);
459     }
460
461 /* Return the origin of the data in the current event's data
462    block with the given block index (starting at 0). */
463 homer_uint32 AliHLTHOMERReader::GetBlockDataOrigin( unsigned long ndx ) const
464     {
465 // see header file for class documentation
466     if ( ndx >= fBlockCnt )
467         return ~(homer_uint32)0;
468     //return (homer_uint32)( ((AliHLTRIBlockDescriptorV1*)fBlocks[ndx].fMetaData)->fSubType1.fID );
469     return (homer_uint32)*(((homer_uint64*)fBlocks[ndx].fMetaData)+kSubType1_64b_Offset);
470     }
471
472 /* Return a specification of the data in the current event's data
473    block with the given block index (starting at 0). */
474 homer_uint32 AliHLTHOMERReader::GetBlockDataSpec( unsigned long ndx ) const
475     {
476 // see header file for class documentation
477     if ( ndx >= fBlockCnt )
478         return ~(homer_uint32)0;
479     //return (homer_uint32)( ((AliHLTRIBlockDescriptorV1*)fBlocks[ndx].fMetaData)->fSubType2.fID );
480     return (homer_uint32)*(((homer_uint64*)fBlocks[ndx].fMetaData)+kSubType2_64b_Offset);
481     }
482
483 /* Find the next data block in the current event with the given
484    data type, origin, and specification. Returns the block's 
485    index. */
486 unsigned long AliHLTHOMERReader::FindBlockNdx( homer_uint64 type, homer_uint32 origin, 
487                                          homer_uint32 spec, unsigned long startNdx ) const
488     {
489 // see header file for class documentation
490     for ( unsigned long n=startNdx; n < fBlockCnt; n++ )
491         {
492         if ( ( type == 0xFFFFFFFFFFFFFFFFULL || *(((homer_uint64*)fBlocks[n].fMetaData)+kType_64b_Offset)==type ) &&
493              ( origin == 0xFFFFFFFF || (homer_uint32)( *(((homer_uint64*)fBlocks[n].fMetaData)+kSubType1_64b_Offset) )==origin ) &&
494              ( spec == 0xFFFFFFFF || (homer_uint32)( *(((homer_uint64*)fBlocks[n].fMetaData)+kSubType2_64b_Offset) )==spec ) )
495             return n;
496         }
497     return ~(unsigned long)0;
498     }
499
500 /* Find the next data block in the current event with the given
501    data type, origin, and specification. Returns the block's 
502    index. */
503 unsigned long AliHLTHOMERReader::FindBlockNdx( char type[8], char origin[4], 
504                                          homer_uint32 spec, unsigned long startNdx ) const
505     {
506 // see header file for class documentation
507     for ( unsigned long n=startNdx; n < fBlockCnt; n++ )
508         {
509         bool found1=true, found2=true;
510         for ( unsigned i = 0; i < 8; i++ )
511             {
512             if ( type[i] != (char)0xFF )
513                 {
514                 found1=false;
515                 break;
516                 }
517             }
518         if ( !found1 )
519             {
520             found1 = true;
521             for ( unsigned i = 0; i < 8; i++ )
522                 {
523                 //printf( "%u: Comparing type '%c' and '%c'\n", i, ((char*)(((homer_uint64*)fBlocks[n].fMetaData)+kType_64b_Offset))[i], type[i] );
524                 if ( ((char*)(((homer_uint64*)fBlocks[n].fMetaData)+kType_64b_Offset))[i] != type[i] )
525                     {
526                     found1=false;
527                     break;
528                     }
529                 }
530             }
531         for ( unsigned i = 0; i < 4; i++ )
532             {
533             if ( origin[i] != (char)0xFF )
534                 {
535                 found2 = false;
536                 break;
537                 }
538             }
539         if ( !found2 )
540             {
541             found2 = true;
542             for ( unsigned i = 0; i < 4; i++ )
543                 {
544                 //printf( "Comparing origin '%c' and '%c'\n", ((char*)(((homer_uint64*)fBlocks[n].fMetaData)+kSubType1_64b_Offset))[i], origin[i] );
545                 if ( ((char*)(((homer_uint64*)fBlocks[n].fMetaData)+kSubType1_64b_Offset))[i] != origin[i] )
546                     {
547                     found2=false;
548                     break;
549                     }
550                 }
551             }
552         //printf( "Comparing spec '0x%08lX' and '0x%08lX'\n", (homer_uint32)( *(((homer_uint64*)fBlocks[n].fMetaData)+kSubType2_64b_Offset) ), spec );
553         if ( found1 && found2 &&
554              ( spec == 0xFFFFFFFF || ((homer_uint32)( *(((homer_uint64*)fBlocks[n].fMetaData)+kSubType2_64b_Offset)) )==spec ) )
555             return n;
556         }
557     return ~(unsigned long)0;
558     }
559
560 /* Return the ID of the node that actually produced this data block.
561    This may be different from the node which sent the data to this
562    monitoring object as returned by GetBlockSendNodeID. */
563 const char* AliHLTHOMERReader::GetBlockCreateNodeID( unsigned long ndx ) const
564     {
565 // see header file for class documentation
566     if ( ndx >= fBlockCnt )
567         return NULL;
568     return fBlocks[ndx].fOriginatingNodeID;
569     }
570
571
572 void AliHLTHOMERReader::Init()
573     {
574 // see header file for class documentation
575     fCurrentEventType = ~(homer_uint64)0;
576     fCurrentEventID = ~(homer_uint64)0;
577     fMaxBlockCnt = fBlockCnt = 0;
578     fBlocks = NULL;
579         
580     fDataSourceMaxCnt = fDataSourceCnt = fTCPDataSourceCnt = fShmDataSourceCnt = 0;
581     fDataSources = NULL;
582
583         
584     fConnectionStatus = 0;
585     fErrorConnection = ~(unsigned int)0;
586
587     fEventRequestAdvanceTime = 0;
588     }
589         
590 bool AliHLTHOMERReader::AllocDataSources( unsigned int sourceCnt )
591     {
592 // see header file for class documentation
593     fDataSources = new DataSource[ sourceCnt ];
594     if ( !fDataSources )
595         return false;
596     fDataSourceCnt = 0;
597     fDataSourceMaxCnt = sourceCnt;
598     return true;
599     }
600
601 int AliHLTHOMERReader::AddDataSource( const char* hostname, unsigned short port, DataSource& source )
602     {
603 // see header file for class documentation
604     struct hostent* he;
605     he = gethostbyname( hostname );
606     if ( he == NULL )
607         {
608         //fprintf( stderr, "Unable to determine remote host address from '%s'.\n", hostname );
609         return EADDRNOTAVAIL;
610         }
611
612     struct sockaddr_in remoteAddr;
613     remoteAddr.sin_family = AF_INET;    // host byte order 
614     remoteAddr.sin_port = htons(port);  // short, network byte order 
615     remoteAddr.sin_addr = *((struct in_addr *)he->h_addr);
616     memset(&(remoteAddr.sin_zero), '\0', 8);  // zero the rest of the struct
617
618     // Create socket and connect to target program on remote node
619     source.fTCPConnection = socket( AF_INET, SOCK_STREAM, 0 );
620     if ( source.fTCPConnection == -1 )
621         {
622         return errno;
623         }
624
625     int ret;
626
627     ret = connect( source.fTCPConnection, (struct sockaddr *)&remoteAddr, sizeof(struct sockaddr) );
628     if ( ret == -1 )
629         {
630         ret=errno;
631         close( source.fTCPConnection );
632         return ret;
633         } 
634
635     ret = write( source.fTCPConnection, MOD_BIN, strlen(MOD_BIN) );
636     if ( ret != (int)strlen(MOD_BIN) )
637         {
638         ret=errno;
639         close( source.fTCPConnection );
640         return ret;
641         }
642
643     char* tmpchar = new char[ strlen( hostname )+1 ];
644     if ( !tmpchar )
645         {
646         close( source.fTCPConnection );
647         return ENOMEM;
648         }
649     strcpy( tmpchar, hostname );
650     source.fHostname = tmpchar;
651
652     source.fType = kTCP;
653     source.fTCPPort = port;
654     source.fData = NULL;
655     source.fDataSize = 0;
656     source.fDataRead = 0;
657     return 0;
658     }
659
660 int AliHLTHOMERReader::AddDataSource( key_t shmKey, int shmSize, DataSource& source )
661     {
662 // see header file for class documentation
663     int ret;
664     char* tmpchar = new char[ MAXHOSTNAMELEN+1 ];
665     if ( !tmpchar )
666         {
667         return ENOMEM;
668         }
669     gethostname( tmpchar, MAXHOSTNAMELEN );
670     tmpchar[MAXHOSTNAMELEN]=(char)0;
671     source.fHostname = tmpchar;
672
673     source.fShmID = shmget( shmKey, shmSize, 0660 );
674     if ( source.fShmID == -1 )
675         {
676         ret = errno;
677         delete [] source.fHostname;
678         return ret;
679         }
680     
681     source.fShmPtr = (void*)shmat( source.fShmID, NULL, 0 );
682
683     if ( !source.fShmPtr )
684         {
685         ret = errno;
686         shmctl( source.fShmID, IPC_RMID, NULL );
687         delete [] source.fHostname;
688         return ret;
689         }
690
691     source.fType = kShm;
692     source.fShmKey = shmKey;
693     source.fShmSize = shmSize;
694     source.fDataSize = 0;
695     source.fDataRead = 0;
696     return 0;
697     }
698
699 int AliHLTHOMERReader::AddDataSource( void* pBuffer, int size, DataSource& source )
700     {
701 // see header file for class documentation
702 // a buffer data source is like a shm source apart from the shm attach and detach
703 // procedure. Furthermore, the size indicator at the beginning of the buffer is not
704 // cleared right before sources are read but after the reading.
705     int ret;
706     if ( !pBuffer || size<=0) return EINVAL;
707
708     char* tmpchar = new char[ MAXHOSTNAMELEN+1 ];
709     if ( !tmpchar )
710         {
711         return ENOMEM;
712         }
713     gethostname( tmpchar, MAXHOSTNAMELEN );
714     tmpchar[MAXHOSTNAMELEN]=(char)0;
715     source.fHostname = tmpchar;
716
717     source.fShmID = -1;
718     // the data buffer does not contain a size indicator in the first 4 bytes
719     // like the shm source buffer. Still we want to use the mechanism to invalidate/
720     // trigger by clearing the size indicator. Take the source.fShmSize variable.
721     source.fShmPtr = &source.fShmSize;
722     source.fType = kBuf;
723     source.fShmKey = 0;
724     source.fShmSize = size;
725     source.fData = pBuffer;
726     source.fDataSize = 0;
727     source.fDataRead = 0;
728     return 0;
729     }
730
731 void AliHLTHOMERReader::FreeDataSources()
732     {
733 // see header file for class documentation
734     for ( unsigned n=0; n < fDataSourceCnt; n++ )
735         {
736         if ( fDataSources[n].fType == kTCP )
737             FreeTCPDataSource( fDataSources[n] );
738         else if ( fDataSources[n].fType == kShm )
739             FreeShmDataSource( fDataSources[n] );
740         }
741     }
742
743 int AliHLTHOMERReader::FreeShmDataSource( DataSource& source )
744     {
745 // see header file for class documentation
746     if ( source.fShmPtr )
747         shmdt( source.fShmPtr );
748 //     if ( source.fShmID != -1 )
749 //      shmctl( source.fShmID, IPC_RMID, NULL );
750     if ( source.fHostname )
751         delete [] source.fHostname;
752     return 0;
753     }
754
755 int AliHLTHOMERReader::FreeTCPDataSource( DataSource& source )
756     {
757 // see header file for class documentation
758     if ( source.fTCPConnection )
759         close( source.fTCPConnection );
760     if ( source.fHostname )
761         delete [] source.fHostname;
762     return 0;
763     }
764
765 int AliHLTHOMERReader::ReadNextEvent( bool useTimeout, unsigned long timeout )
766     {
767 // see header file for class documentation
768     if ( fDataSourceCnt<=0 )
769         return ENXIO;
770     // Clean up currently active event.
771     ReleaseCurrentEvent();
772     int ret;
773     // Trigger all configured data sources
774     for ( unsigned n = 0; n<fDataSourceCnt; n++ )
775         {
776         if ( fDataSources[n].fType == kTCP )
777             ret = TriggerTCPSource( fDataSources[n], useTimeout, timeout );
778         else if ( fDataSources[n].fType == kShm )
779             ret = TriggerShmSource( fDataSources[n], useTimeout, timeout );
780         if ( ret )
781             {
782             fErrorConnection = n;
783             fConnectionStatus=ret;
784             return fConnectionStatus;
785             }
786         }
787     // Now read in data from the configured data source
788     ret = ReadDataFromTCPSources( fTCPDataSourceCnt, fDataSources, useTimeout, timeout );
789     if ( ret )
790         {
791         return ret;
792         }
793     ret = ReadDataFromShmSources( fShmDataSourceCnt, fDataSources+fTCPDataSourceCnt, useTimeout, timeout );
794     if ( ret )
795         {
796         return ret;
797         }
798 //     for ( unsigned n = 0; n<fDataSourceCnt; n++ )
799 //      {
800 //      if ( fDataSources[n].fType == kTCP )
801 //          ret = ReadDataFromTCPSource( fDataSources[n], useTimeout, timeout );
802 //      else
803 //          ret = ReadDataFromShmSource( fDataSources[n], useTimeout, timeout );
804 //      if ( ret )
805 //          {
806 //          fErrorConnection = n;
807 //          fConnectionStatus=ret;
808 //          return fConnectionStatus;
809 //          }
810 //      }
811     //Check to see that all sources contributed data for the same event
812     homer_uint64 eventID;
813     homer_uint64 eventType;
814     eventID = GetSourceEventID( fDataSources[0] );
815     eventType = GetSourceEventType( fDataSources[0] );
816     for ( unsigned n = 1; n < fDataSourceCnt; n++ )
817         {
818         if ( GetSourceEventID( fDataSources[n] ) != eventID || GetSourceEventType( fDataSources[n] ) != eventType )
819             {
820             fErrorConnection = n;
821             fConnectionStatus=56;//EBADRQC;
822             return fConnectionStatus;
823             }
824         }
825     // Find all the different data blocks contained in the data from all
826     // the sources.
827     for ( unsigned n = 0; n < fDataSourceCnt; n++ )
828         {
829         ret = ParseSourceData( fDataSources[n] );
830         if ( ret )
831             {
832             fErrorConnection = n;
833             fConnectionStatus=57;//EBADSLT;
834             return fConnectionStatus;
835             }
836         }
837     fCurrentEventID = eventID;
838     fCurrentEventType = eventType;
839     return 0;
840     }
841
842 void AliHLTHOMERReader::ReleaseCurrentEvent()
843     {
844 // see header file for class documentation
845     // sources.fDataRead = 0;
846     // fMaxBlockCnt
847     fCurrentEventID = ~(homer_uint64)0;
848     fCurrentEventType = ~(homer_uint64)0;
849     for ( unsigned n = 0; n < fDataSourceCnt; n++ )
850         {
851         if ( fDataSources[n].fData )
852             {
853             if ( fDataSources[n].fType == kTCP )
854                 delete [] (homer_uint8*)fDataSources[n].fData;
855             fDataSources[n].fData = NULL;
856             }
857         fDataSources[n].fDataSize = fDataSources[n].fDataRead = 0;
858         }
859     if ( fBlocks )
860         {
861         for ( unsigned n = 0; n < fMaxBlockCnt; n++ )
862             {
863             if ( fBlocks[n].fOriginatingNodeID )
864                 delete [] fBlocks[n].fOriginatingNodeID;
865             }
866         delete [] fBlocks;
867         fBlocks=0;
868         fMaxBlockCnt = 0;
869         fBlockCnt=0;
870         }
871     }
872
873 int AliHLTHOMERReader::TriggerTCPSource( DataSource& source, bool useTimeout, unsigned long timeoutUsec )
874     {
875 // see header file for class documentation
876     int ret;
877     struct timeval oldSndTO, newSndTO;
878     if ( useTimeout )
879         {
880         socklen_t optlen=sizeof(oldSndTO);
881         ret = getsockopt( source.fTCPConnection, SOL_SOCKET, SO_SNDTIMEO, &oldSndTO, &optlen );
882         if ( ret )
883             {
884             return errno;
885             }
886         if ( optlen!=sizeof(oldSndTO) )
887             {
888             return ENXIO;
889             }
890         newSndTO.tv_sec = timeoutUsec / 1000000;
891         newSndTO.tv_usec = timeoutUsec - (newSndTO.tv_sec*1000000);
892         ret = setsockopt( source.fTCPConnection, SOL_SOCKET, SO_SNDTIMEO, &newSndTO, sizeof(newSndTO) );
893         if ( ret )
894             {
895             return errno;
896             }
897         }
898     // Send one event request
899     if ( !fEventRequestAdvanceTime )
900         {
901         ret = write( source.fTCPConnection, GET_ONE, strlen(GET_ONE) );
902         
903         if ( ret != (int)strlen(GET_ONE) )
904             {
905             ret=errno;
906             setsockopt( source.fTCPConnection, SOL_SOCKET, SO_SNDTIMEO, &oldSndTO, sizeof(oldSndTO) );
907             return ret;
908             }
909         }
910     else
911         {
912         char tmpCmd[ 128 ];
913
914         int len = snprintf( tmpCmd, 128, "FIRST ORBIT EVENT 0x%Lu\n", (unsigned long long)fEventRequestAdvanceTime );
915         if ( len>128 || len<0 )
916             {
917             ret=EMSGSIZE;
918             setsockopt( source.fTCPConnection, SOL_SOCKET, SO_SNDTIMEO, &oldSndTO, sizeof(oldSndTO) );
919             return ret;
920             }
921         
922         ret = write( source.fTCPConnection, tmpCmd, strlen(tmpCmd) );
923         
924         if ( ret != (int)strlen(tmpCmd) )
925             {
926             ret=errno;
927             setsockopt( source.fTCPConnection, SOL_SOCKET, SO_SNDTIMEO, &oldSndTO, sizeof(oldSndTO) );
928             return ret;
929             }
930         
931         }
932     return 0;
933     }
934
935 int AliHLTHOMERReader::TriggerShmSource( DataSource& source, bool, unsigned long )
936     {
937 // see header file for class documentation
938 // clear the size indicator in the first 4 bytes of the buffer to request data
939 // from the HOMER writer.
940     if ( source.fShmPtr )
941         {
942         *(homer_uint32*)( source.fShmPtr ) = 0;
943         return 0;
944         }
945     else
946         return EFAULT;
947     }
948
949 int AliHLTHOMERReader::ReadDataFromTCPSources( unsigned sourceCnt, DataSource* sources, bool useTimeout, unsigned long timeout )
950     {
951 // see header file for class documentation
952     bool toRead = false;
953     do
954         {
955         fd_set conns;
956         FD_ZERO( &conns );
957         int highestConn=0;
958         toRead = false;
959         unsigned firstConnection=~(unsigned)0;
960         for ( unsigned long n = 0; n < sourceCnt; n++ )
961             {
962             if ( sources[n].fDataSize == 0 // size specifier not yet read
963                  || sources[n].fDataRead < sources[n].fDataSize ) // Data not yet read fully
964                 {
965                 toRead = true;
966                 FD_SET( sources[n].fTCPConnection, &conns );
967                 if ( sources[n].fTCPConnection > highestConn )
968                     highestConn = sources[n].fTCPConnection;
969                 fcntl( sources[n].fTCPConnection, F_SETFL, O_NONBLOCK );
970                 if ( firstConnection == ~(unsigned)0 )
971                     firstConnection = n;
972                 }
973             else
974                 {
975                 fcntl( sources[n].fTCPConnection, F_SETFL, 0 );
976                 }
977             }
978         if ( toRead )
979             {
980             struct timeval tv, *ptv;
981             if ( useTimeout )
982                 {
983                 tv.tv_sec = timeout / 1000000;
984                 tv.tv_usec = timeout - (tv.tv_sec*1000000);
985                 ptv = &tv;
986                 }
987             else
988                 ptv = NULL;
989             // wait until something is ready to be read
990             // either for timeout usecs or until eternity
991             int ret;
992             ret = select( highestConn+1, &conns, NULL, NULL, ptv ); 
993             if ( ret <=0 )
994                 {
995                 fErrorConnection = firstConnection;
996                 if ( errno )
997                     fConnectionStatus = errno;
998                 else
999                     fConnectionStatus = ETIMEDOUT;
1000                 return fConnectionStatus;
1001                 }
1002             for ( unsigned n = 0; n < sourceCnt; n++ )
1003                 {
1004                 if ( FD_ISSET( sources[n].fTCPConnection, &conns ) )
1005                     {
1006                     if ( sources[n].fDataSize == 0 )
1007                         {
1008                         ret=read( sources[n].fTCPConnection, &(sources[n].fDataSize), sizeof(homer_uint32) );
1009                         if ( ret != sizeof(homer_uint32) )
1010                             {
1011                             fErrorConnection = n;
1012                             if ( errno )
1013                                 fConnectionStatus = errno;
1014                             else
1015                                 fConnectionStatus = ENOMSG;
1016                             return fConnectionStatus;
1017                             }
1018                         sources[n].fDataSize = ntohl( sources[n].fDataSize );
1019                         sources[n].fDataRead = 0;
1020                         sources[n].fData = new homer_uint8[ sources[n].fDataSize ];
1021                         if ( !sources[n].fData )
1022                             {
1023                             fErrorConnection = n;
1024                             fConnectionStatus = ENOMEM;
1025                             return fConnectionStatus;
1026                             }
1027                         }
1028                     else if ( sources[n].fData && sources[n].fDataRead < sources[n].fDataSize)
1029                         {
1030                         ret=read( sources[n].fTCPConnection, ((homer_uint8*)sources[n].fData)+sources[n].fDataRead, sources[n].fDataSize-sources[n].fDataRead );
1031                         if ( ret>0 )
1032                             sources[n].fDataRead += ret;
1033                         else if ( ret == 0 )
1034                             {
1035                             fErrorConnection = n;
1036                             fConnectionStatus = ECONNRESET;
1037                             return fConnectionStatus;
1038                             }
1039                         else
1040                             {
1041                             fErrorConnection = n;
1042                             fConnectionStatus = errno;
1043                             return fConnectionStatus;
1044                             }
1045                         }
1046                     else
1047                         {
1048                         fErrorConnection = n;
1049                         fConnectionStatus = ENXIO;
1050                         return fConnectionStatus;
1051                         }
1052                     }
1053                 }
1054             }
1055         }
1056     while ( toRead );
1057     return 0;
1058     }
1059
1060 /*
1061 int AliHLTHOMERReader::ReadDataFromTCPSources( DataSource& source, bool useTimeout, unsigned long timeout )
1062     {
1063 #warning TODO If useTimeout: Set sockets to nonblocking, select + loop around GET_ONE write
1064     // Send one event request
1065     ret = write( source.fTCPConnection, GET_ONE, strlen(GET_ONE) );
1066     if ( ret != strlen(GET_ONE) )
1067         {
1068         return errno;
1069         }
1070     // wait for and read back size specifier
1071     unsigned sizeNBO;
1072     // The value transmitted is binary, in network byte order
1073     ret = read( source.fTCPConnection, &sizeNBO, sizeof(sizeNBO) );
1074     if ( ret != sizeof(sizeNBO) )
1075         {
1076         return errno;
1077         }
1078     // Convert back to host byte order
1079     source.fDataSize = ntohl( sizeNBO );
1080     source.fData = new homer_uint8[ source.fDataSize ];
1081     unsigned long dataRead=0, toRead;
1082     if ( !source.fData )
1083         {
1084         char buffer[1024];
1085         // Read in data into buffer in order not to block connection
1086         while ( dataRead < source.fDataSize )
1087             {
1088             if ( source.fDataSize-dataRead > 1024 )
1089                 toRead = 1024;
1090             else
1091                 toRead = source.fDataSize-dataRead;
1092             ret = read( source.fTCPConnection, buffer, toRead );
1093             if ( ret > 0 )
1094                 dataRead += ret;
1095             else
1096                 return errno;
1097             }
1098         return ENOMEM;
1099         }
1100     while ( dataRead < source.fDataSize )
1101         {
1102         toRead = source.fDataSize-dataRead;
1103         ret = read( source.fTCPConnection, source.fData+dataRead, toRead );
1104         if ( ret > 0 )
1105             dataRead += ret;
1106         else if ( ret == 0 && useTimeout )
1107             {
1108             struct timeval tv;
1109             tv.tv_sec = timeout / 1000000;
1110             tv.tv_usec = timeout - (tv.tv_sec*1000000);
1111             fd_set conns;
1112             FD_ZERO( &conns );
1113             FD_SET( source.fTCPConnection, &conns );
1114             ret = select( source.fTCPConnection+1, &conns, NULL, NULL );
1115             if ( ret <=0 )
1116                 return errno;
1117             }
1118         else if ( ret == 0 )
1119             {
1120             if ( errno == EOK )
1121                 return ECONNRESET;
1122             else
1123                 return errno;
1124             }
1125         else
1126             {
1127             return errno;
1128             }
1129         }
1130     return 0;
1131     }
1132 */
1133
1134 /*
1135 int AliHLTHOMERReader::ReadDataFromShmSource( DataSource& source, bool useTimeout, unsigned long timeout )
1136     {
1137     
1138     }
1139 */
1140
1141 int AliHLTHOMERReader::ReadDataFromShmSources( unsigned sourceCnt, DataSource* sources, bool useTimeout, unsigned long timeout )
1142     {
1143 // see header file for class documentation
1144     struct timeval tv1, tv2;
1145     bool found=false;
1146     bool all=true;
1147     if ( useTimeout )
1148         gettimeofday( &tv1, NULL );
1149     do
1150         {
1151         found = false;
1152         all = true;
1153         for ( unsigned n = 0; n < sourceCnt; n++ )
1154             {
1155             if ( !sources[n].fDataSize )
1156                 all = false;
1157             if ( sources[n].fShmPtr && *(homer_uint32*)sources[n].fShmPtr>0 && !sources[n].fDataSize )
1158                 {
1159                 found = true;
1160                 sources[n].fDataSize = *(homer_uint32*)sources[n].fShmPtr;
1161                 if (sources[n].fType==kBuf)
1162                   {
1163                     // the data buffer is already set to fData, just need to set fDataSize member
1164                     // to invalidate after the first reading. Subsequent calls to ReadNextEvent return 0
1165                     TriggerShmSource( sources[n], 0, 0 );
1166                   } else 
1167                   {
1168                     sources[n].fData = ((homer_uint8*)sources[n].fShmPtr)+sizeof(homer_uint32);
1169                   }
1170                 }
1171             }
1172         if ( found && useTimeout )
1173             gettimeofday( &tv1, NULL );
1174         if ( !all && useTimeout )
1175             {
1176             gettimeofday( &tv2, NULL );
1177             unsigned long long tdiff;
1178             tdiff = tv2.tv_sec-tv1.tv_sec;
1179             tdiff *= 1000000;
1180             tdiff += tv2.tv_usec-tv1.tv_usec;
1181             if ( tdiff > timeout )
1182                 return ETIMEDOUT;
1183             }
1184         if ( !all )
1185             usleep( 0 );
1186         }
1187     while ( !all );
1188     return 0;
1189     }
1190
1191 int AliHLTHOMERReader::ParseSourceData( DataSource& source )
1192     {
1193 // see header file for class documentation
1194     if ( source.fData )
1195         {
1196         homer_uint8 sourceByteOrder = ((homer_uint8*)source.fData)[ kByteOrderAttribute_8b_Offset ];
1197         homer_uint64 blockCnt = Swap( kHOMERNativeByteOrder, sourceByteOrder, ((homer_uint64*)source.fData)[ kSubType2_64b_Offset ] );
1198         int ret=ReAllocBlocks( fMaxBlockCnt+blockCnt );
1199         if ( ret )
1200             return ret;
1201         homer_uint64 descrOffset = Swap( kHOMERNativeByteOrder, sourceByteOrder, ((homer_uint64*)source.fData)[ kOffset_64b_Offset ] );
1202         for ( homer_uint64 n = 0; n < blockCnt && fBlockCnt < fMaxBlockCnt; n++, fBlockCnt++ )
1203             {
1204             homer_uint8* descr = ((homer_uint8*)source.fData)+descrOffset;
1205             unsigned descrLen = Swap( kHOMERNativeByteOrder, sourceByteOrder, ((homer_uint64*)descr)[ kLength_64b_Offset ] );
1206             fBlocks[fBlockCnt].fSource = source.fNdx;
1207             fBlocks[fBlockCnt].fData = ((homer_uint8*)source.fData) + Swap( kHOMERNativeByteOrder, sourceByteOrder, ((homer_uint64*)descr)[ kOffset_64b_Offset ] );
1208             fBlocks[fBlockCnt].fLength = Swap( kHOMERNativeByteOrder, sourceByteOrder, ((homer_uint64*)descr)[ kSize_64b_Offset ] );
1209             fBlocks[fBlockCnt].fMetaData = (homer_uint64*)descr;
1210             struct in_addr tmpA;
1211             tmpA.s_addr = (homer_uint32)( ((homer_uint64*)descr)[ kProducerNode_64b_Offset ] );
1212             char* addr = inet_ntoa( tmpA );
1213             char* tmpchar = new char[ strlen(addr)+1 ];
1214             if ( !tmpchar )
1215                 return ENOMEM;
1216             strcpy( tmpchar, addr );
1217             fBlocks[fBlockCnt].fOriginatingNodeID = tmpchar;
1218             descrOffset += descrLen;
1219             }
1220         return 0;
1221         }
1222     return EFAULT;
1223     }
1224         
1225 int AliHLTHOMERReader::ReAllocBlocks( unsigned long newCnt )
1226     {
1227 // see header file for class documentation
1228     DataBlock* newBlocks;
1229     newBlocks = new DataBlock[ newCnt ];
1230     if ( !newBlocks )
1231         return ENOMEM;
1232     unsigned long cpCnt = (newCnt > fMaxBlockCnt) ? fMaxBlockCnt : newCnt;
1233     memcpy( newBlocks, fBlocks, cpCnt*sizeof(DataBlock) );
1234     if ( newCnt > fMaxBlockCnt )
1235         memset( newBlocks+fMaxBlockCnt, 0, (newCnt-fMaxBlockCnt)*sizeof(DataBlock) );
1236     if ( fBlocks )
1237         delete [] fBlocks;
1238     fBlocks = newBlocks;
1239     fMaxBlockCnt = newCnt;
1240     return 0;
1241     }
1242
1243 homer_uint64 AliHLTHOMERReader::GetSourceEventID( DataSource& source )
1244     {
1245 // see header file for class documentation
1246     homer_uint8 sourceByteOrder = ((homer_uint8*)source.fData)[ kByteOrderAttribute_8b_Offset ];
1247     return Swap( kHOMERNativeByteOrder, sourceByteOrder, ((homer_uint64*)source.fData)[ kSubType1_64b_Offset ] );
1248     }
1249
1250 homer_uint64 AliHLTHOMERReader::GetSourceEventType( DataSource& source )
1251     {
1252 // see header file for class documentation
1253     homer_uint8 sourceByteOrder = ((homer_uint8*)source.fData)[ kByteOrderAttribute_8b_Offset ];
1254     return Swap( kHOMERNativeByteOrder, sourceByteOrder, ((homer_uint64*)source.fData)[ kType_64b_Offset ] );
1255     }
1256
1257 homer_uint64 AliHLTHOMERReader::Swap( homer_uint8 destFormat, homer_uint8 sourceFormat, homer_uint64 source ) const
1258     {
1259 // see header file for class documentation
1260     if ( destFormat == sourceFormat )
1261         return source;
1262     else
1263         return ((source & 0xFFULL) << 56) | 
1264         ((source & 0xFF00ULL) << 40) | 
1265         ((source & 0xFF0000ULL) << 24) | 
1266         ((source & 0xFF000000ULL) << 8) | 
1267         ((source & 0xFF00000000ULL) >> 8) | 
1268         ((source & 0xFF0000000000ULL) >> 24) | 
1269         ((source & 0xFF000000000000ULL) >>  40) | 
1270         ((source & 0xFF00000000000000ULL) >> 56);
1271     }
1272
1273 homer_uint32 AliHLTHOMERReader::Swap( homer_uint8 destFormat, homer_uint8 sourceFormat, homer_uint32 source ) const
1274     {
1275 // see header file for class documentation
1276     if ( destFormat == sourceFormat )
1277         return source;
1278     else
1279         return ((source & 0xFFUL) << 24) | 
1280         ((source & 0xFF00UL) << 8) | 
1281         ((source & 0xFF0000UL) >> 8) | 
1282         ((source & 0xFF000000UL) >> 24);
1283     }
1284
1285 AliHLTHOMERReader* AliHLTHOMERReaderCreate(const void* pBuffer, int size)
1286     {
1287 // see header file for function documentation
1288       return new AliHLTHOMERReader(pBuffer, size);
1289     }
1290
1291 void AliHLTHOMERReaderDelete(AliHLTHOMERReader* pInstance)
1292     {
1293 // see header file for function documentation
1294       if (pInstance) delete pInstance;
1295     }
1296
1297 /*
1298 ***************************************************************************
1299 **
1300 ** $Author$ - Initial Version by Timm Morten Steinbeck
1301 **
1302 ** $Id$ 
1303 **
1304 ***************************************************************************
1305 */