00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143
00144
00145
00146
00147
00148
00149
00150
00151
00152
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208
00209
00210
00211
00212
00213
00214
00215
00216
00217
00218
00219
00220
00221
00222
00223
00224
00225
00226
00227
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238
00239
00240
00241
00242
00243
00244
00245
00246
00247
00248
00249
00250
00251
00252
00253
00254
00255
00256
00257 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00258
00259
00260
00261
00262
00263 #define TRACE
00264 #include "midas.h"
00265 #include "msystem.h"
00266
00267 #ifdef INCLUDE_FTPLIB
00268 #include "ftplib.h"
00269 #endif
00270
00271 #ifdef INCLUDE_ZLIB
00272 #include "zlib.h"
00273 #endif
00274
00275 #define INCLUDE_LOGGING
00276 #include "ybos.h"
00277
00278 INT yb_tid_size[] = {
00279 0,
00280 2,
00281 1,
00282 4,
00283 4,
00284 8,
00285 0,
00286 0,
00287 1,
00288 };
00289
00290
00291
00292 INT yb_any_dev_os_read(INT handle, INT type, void *prec, DWORD nbytes, DWORD * nread);
00293 INT yb_any_dev_os_write(INT handle, INT type, void *prec, DWORD nbytes, DWORD * written);
00294 INT yb_ymfile_update(int slot, int fmt, void *pevt);
00295 INT yb_ymfile_open(int *slot, int fmt, void *pevt, char *svpath, INT file_mode);
00296 INT yb_file_fragment(EQUIPMENT * eqp, EVENT_HEADER * pevent, INT run_number, char *path);
00297
00298 INT midas_event_skip(INT evtn);
00299 INT ybos_physrec_skip(INT bl);
00300
00301 INT ybos_physrec_get(DWORD ** prec, DWORD * readn);
00302 INT midas_physrec_get(void *prec, DWORD * readn);
00303
00304 void yb_any_bank_event_display(void *pevent, INT data_fmt, INT dsp_fmt);
00305 void yb_any_raw_event_display(void *pevent, INT data_fmt, INT dsp_fmt);
00306
00307 void yb_any_raw_bank_display(void *pbank, INT data_fmt, INT dsp_fmt);
00308 void ybos_bank_display(YBOS_BANK_HEADER * pybk, INT dsp_fmt);
00309 void midas_bank_display(BANK * pbk, INT dsp_fmt);
00310 void midas_bank_display32(BANK32 * pbk, INT dsp_fmt);
00311
00312 INT ybos_event_get(DWORD ** plrl, DWORD * size);
00313 INT midas_event_get(void **pevent, DWORD * size);
00314 INT ybos_event_swap(DWORD * pevt);
00315
00316 INT ybos_buffer_flush(LOG_CHN * log_chn, INT run_number);
00317 INT ybos_logfile_open(INT type, char *path, HNDLE * handle);
00318 INT ybos_logfile_close(INT type, HNDLE handle);
00319 void ybos_log_dump(LOG_CHN * log_chn, short int event_id, INT run_number);
00320
00321
00322
00323
00324
00325
00326
00327
00328
00329
00330
00331
00332
00333
00334
00335
00336
00337 #ifdef INCLUDE_FTPLIB
00338 FTP_CON *ftp_con;
00339 #endif
00340
00341
00342 DWORD *pbot, *pbktop = NULL;
00343 char *ptopmrd;
00344 DWORD magta[3] = { 0x00000004, 0x544f422a, 0x00007ff8 };
00345
00346
00347 R_YM_FILE ymfile[MAX_YM_FILE];
00348 struct stat *filestat;
00349
00350 #ifdef INCLUDE_ZLIB
00351 gzFile filegz;
00352 #endif
00353
00354
00355 struct {
00356 INT handle;
00357 char name[MAX_FILE_PATH];
00358
00359 char *pmp;
00360 EVENT_HEADER *pmh;
00361 EVENT_HEADER *pme;
00362 char *pmrd;
00363
00364 char *pmagta;
00365 YBOS_PHYSREC_HEADER *pyh;
00366 DWORD *pylrl;
00367 DWORD *pyrd;
00368
00369 DWORD evtn;
00370 DWORD serial;
00371 DWORD evtlen;
00372 DWORD size;
00373 DWORD recn;
00374 INT fmt;
00375 INT type;
00376 DWORD runn;
00377 BOOL zipfile;
00378 BOOL magtafl;
00379 } my;
00380
00381
00382 #endif
00383
00384
00385
00386
00387
00388
00389
00390
00391
00392
00393
00394
00395
00396
00397
00398
00399
00400
00401
00402
00403
00404
00405
00406
00407 void ybk_init(DWORD * plrl)
00408 {
00409 *plrl = 0;
00410 return;
00411 }
00412
00413
00414 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00415
00416 static YBOS_BANK_HEADER *__pbkh;
00417
00418
00419 #endif
00420
00421
00422
00423
00424
00425
00426
00427
00428
00429
00430
00431
00432
00433
00434
00435
00436
00437 void ybk_create(DWORD * plrl, char *bkname, DWORD bktype, void *pbkdat)
00438 {
00439 DWORD dname = 0;
00440 __pbkh = (YBOS_BANK_HEADER *) (((DWORD *) (plrl + 1)) + (*(DWORD *) plrl));
00441 strncpy((char *) &dname, bkname, 4);
00442 __pbkh->name = *((DWORD *) bkname);
00443 __pbkh->number = 1;
00444 __pbkh->index = 0;
00445 __pbkh->length = 0;
00446 __pbkh->type = bktype;
00447 *((DWORD **) pbkdat) = (DWORD *) (__pbkh + 1);
00448 return;
00449 }
00450
00451
00452 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00453
00454 static DWORD *__pchaosi4;
00455
00456
00457 void ybk_create_chaos(DWORD * plrl, char *bkname, DWORD bktype, void *pbkdat)
00458
00459
00460
00461
00462
00463
00464
00465
00466
00467
00468
00469
00470
00471
00472
00473 {
00474 DWORD dname = 0;
00475 __pbkh = (YBOS_BANK_HEADER *) ((plrl + 1) + (*plrl));
00476 strncpy((char *) &dname, bkname, 4);
00477 __pbkh->name = *((DWORD *) bkname);
00478 __pbkh->number = 1;
00479 __pbkh->index = 0;
00480 __pbkh->length = 0;
00481 __pbkh->type = bktype;
00482
00483 *((DWORD **) pbkdat) = (DWORD *) (__pbkh + 1);
00484 __pchaosi4 = (DWORD *) (*(DWORD *) pbkdat);
00485 *((DWORD **) pbkdat) += 1;
00486 return;
00487 }
00488
00489
00490 INT ybk_close_chaos(DWORD * plrl, DWORD bktype, void *pbkdat)
00491
00492
00493
00494
00495
00496
00497
00498
00499
00500
00501
00502
00503
00504
00505
00506 {
00507 switch (bktype) {
00508 case D8_BKTYPE:
00509 *__pchaosi4 = (DWORD) ((double *) pbkdat - (double *) __pchaosi4 - 1);
00510 break;
00511 case I4_BKTYPE:
00512 case F4_BKTYPE:
00513 *__pchaosi4 = (DWORD) ((DWORD *) pbkdat - __pchaosi4 - 1);
00514 break;
00515 case I2_BKTYPE:
00516 *__pchaosi4 = (DWORD) ((WORD *) pbkdat - (WORD *) __pchaosi4 - 2);
00517 SWAP_D2WORD(__pchaosi4);
00518 break;
00519 case I1_BKTYPE:
00520 case A1_BKTYPE:
00521 *__pchaosi4 = (DWORD) ((BYTE *) pbkdat - (BYTE *) __pchaosi4 - 4);
00522 break;
00523 default:
00524 printf(" unknown YBOS bank type (%ld)\n", bktype);
00525 break;
00526 }
00527
00528 return ybk_close(plrl, pbkdat);
00529 }
00530
00531
00532 #endif
00533
00534
00535
00536
00537
00538
00539
00540
00541
00542
00543
00544
00545
00546
00547
00548 INT ybk_close(DWORD * plrl, void *pbkdat)
00549 {
00550 DWORD tdlen;
00551
00552 if (((DWORD) pbkdat & 0x1) != 0) {
00553 *((BYTE *) pbkdat) = 0x0f;
00554 pbkdat = (void *) (((BYTE *) pbkdat) + 1);
00555 }
00556 if (((DWORD) pbkdat & 0x2) != 0) {
00557 *((WORD *) pbkdat) = 0x0ffb;
00558 pbkdat = (void *) (((WORD *) pbkdat) + 1);
00559 }
00560
00561
00562 tdlen = (DWORD) ((char *) pbkdat - (char *) __pbkh - sizeof(YBOS_BANK_HEADER));
00563
00564
00565 __pbkh->length = (tdlen + 4) / 4;
00566
00567
00568 *plrl += __pbkh->length + (sizeof(YBOS_BANK_HEADER) / 4) - 1;
00569 return __pbkh->length;
00570 }
00571
00572
00573
00574
00575
00576
00577
00578 INT ybk_size(DWORD * plrl)
00579 {
00580 return (*((DWORD *) plrl) * 4 + 4);
00581 }
00582
00583
00584
00585
00586
00587
00588
00589
00590
00591
00592
00593 INT ybk_list(DWORD * plrl, char *bklist)
00594 {
00595
00596 YBOS_BANK_HEADER *pbk;
00597 DWORD *pendevt, nbk;
00598
00599 pbk = (YBOS_BANK_HEADER *) (plrl + 1);
00600
00601
00602 pendevt = (DWORD *) pbk + *plrl;
00603
00604
00605 if (pbk->type >= MAX_BKTYPE)
00606 return (YB_WRONG_BANK_TYPE);
00607
00608
00609 nbk = 0;
00610 bklist[0] = 0;
00611
00612
00613 while ((DWORD *) pbk < pendevt) {
00614
00615 nbk++;
00616
00617 if (nbk > YB_BANKLIST_MAX) {
00618 cm_msg(MINFO, "ybk_list", "over %i banks -> truncated", YB_BANKLIST_MAX);
00619 return (nbk);
00620 }
00621
00622
00623 strncat(bklist, (char *) &(pbk->name), 4);
00624
00625
00626 pbk = (YBOS_BANK_HEADER *) (((DWORD *) pbk) + pbk->length + 4);
00627 }
00628 return (nbk);
00629 }
00630
00631
00632
00633
00634
00635
00636
00637
00638
00639
00640
00641
00642 INT ybk_find(DWORD * plrl, char *bkname, DWORD * bklen, DWORD * bktype, void **pbk)
00643 {
00644 YBOS_BANK_HEADER *pevt;
00645 DWORD *pendevt;
00646
00647 pevt = (YBOS_BANK_HEADER *) (plrl + 1);
00648
00649
00650 pendevt = (DWORD *) pevt + *plrl;
00651
00652
00653 if (pevt->type >= MAX_BKTYPE)
00654 return (YB_WRONG_BANK_TYPE);
00655
00656
00657 *bklen = 0;
00658 *bktype = 0;
00659
00660
00661 while ((DWORD *) pevt < pendevt) {
00662
00663 if (strncmp((char *) &(pevt->name), bkname, 4) == 0) {
00664
00665 *bklen = pevt->length - 1;
00666
00667
00668 *bktype = pevt->type;
00669
00670
00671 *pbk = &pevt->name;
00672 return (YB_SUCCESS);
00673 } else {
00674
00675 pevt = (YBOS_BANK_HEADER *) (((DWORD *) pevt) + pevt->length + 4);
00676 }
00677 }
00678 return (YB_BANK_NOT_FOUND);
00679 }
00680
00681
00682
00683
00684
00685
00686
00687
00688
00689 INT ybk_locate(DWORD * plrl, char *bkname, void *pdata)
00690 {
00691 YBOS_BANK_HEADER *pybk;
00692 DWORD *pendevt;
00693
00694 pybk = (YBOS_BANK_HEADER *) (plrl + 1);
00695
00696
00697 pendevt = (DWORD *) pybk + *plrl;
00698
00699
00700 if (pybk->type >= MAX_BKTYPE)
00701 return (YB_WRONG_BANK_TYPE);
00702
00703
00704 while ((DWORD *) pybk < pendevt) {
00705
00706 if (strncmp((char *) &(pybk->name), bkname, 4) == 0) {
00707
00708
00709
00710 *((void **) pdata) = pybk + 1;
00711 return (pybk->length - 1);
00712 } else {
00713
00714 pybk = (YBOS_BANK_HEADER *) (((DWORD *) pybk) + pybk->length + 4);
00715 }
00716 }
00717 return (YB_BANK_NOT_FOUND);
00718 }
00719
00720
00721
00722
00723
00724
00725
00726
00727
00728 INT ybk_iterate(DWORD * plrl, YBOS_BANK_HEADER ** pybkh, void **pdata)
00729 {
00730 static int len;
00731 static DWORD *pendevt;
00732 static DWORD *pybk;
00733
00734
00735
00736
00737 if (*pybkh == NULL) {
00738
00739 *pybkh = (YBOS_BANK_HEADER *) (plrl + 1);
00740
00741 if ((*pybkh)->type > I1_BKTYPE) {
00742 *pdata = NULL;
00743 *pybkh = (YBOS_BANK_HEADER *) * pdata;
00744 return (YB_WRONG_BANK_TYPE);
00745 }
00746
00747
00748 pendevt = plrl + *plrl;
00749
00750
00751
00752
00753
00754
00755
00756
00757
00758
00759
00760
00761
00762 } else {
00763
00764
00765 len = (*pybkh)->length;
00766 (YBOS_BANK_HEADER *) (*pybkh)++;
00767 pybk = (DWORD *) * pybkh;
00768 pybk += len - 1;
00769 *pybkh = (YBOS_BANK_HEADER *) pybk;
00770 }
00771
00772
00773 if ((DWORD *) (*pybkh) < pendevt) {
00774
00775 *pdata = (void *) (*pybkh + 1);
00776
00777
00778 return ((*pybkh)->length - 1);
00779 } else {
00780
00781 *pdata = NULL;
00782 *pybkh = (YBOS_BANK_HEADER *) * pdata;
00783 return (-1);
00784 }
00785 }
00786
00787
00788 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00789
00790
00791
00792
00793
00794
00795 INT feodb_file_dump(EQUIPMENT * eqp, char *eqpname,
00796 char *pevent, INT run_number, char *path)
00797
00798
00799
00800
00801
00802
00803
00804
00805
00806
00807
00808
00809
00810
00811
00812 {
00813 EQUIPMENT *peqp;
00814 INT index, size, status;
00815 HNDLE hDB, hKey, hKeydump;
00816 char strpath[MAX_FILE_PATH], Dumpfile[MAX_FILE_PATH];
00817 char odb_entry[MAX_FILE_PATH];
00818 BOOL eqpfound = FALSE;
00819
00820 cm_get_experiment_database(&hDB, &hKey);
00821 peqp = eqp;
00822
00823
00824 while (*(peqp->name) != 0) {
00825 if (equal_ustring((peqp->name), eqpname)) {
00826 eqpfound = TRUE;
00827 break;
00828 }
00829 peqp++;
00830 }
00831 if (!eqpfound)
00832 return DB_INVALID_NAME;
00833
00834
00835 sprintf(odb_entry, "/Equipment/%s/Dump", path);
00836 status = db_find_key(hDB, 0, odb_entry, &hKey);
00837 if (status != DB_SUCCESS) {
00838 cm_msg(MINFO, "ybos_odb_file_dump", "odb_access_file -I- %s not found", odb_entry);
00839 return YB_SUCCESS;
00840 }
00841 index = 0;
00842 while ((status = db_enum_key(hDB, hKey, index, &hKeydump)) != DB_NO_MORE_SUBKEYS) {
00843 if (status == DB_SUCCESS) {
00844 size = sizeof(strpath);
00845 db_get_path(hDB, hKeydump, strpath, size);
00846 db_get_value(hDB, 0, strpath, Dumpfile, &size, TID_STRING, TRUE);
00847 yb_file_fragment(peqp, (EVENT_HEADER *) pevent, run_number, Dumpfile);
00848 }
00849 index++;
00850 }
00851 return (YB_SUCCESS);
00852 }
00853
00854
00855 INT yb_file_fragment(EQUIPMENT * eqp, EVENT_HEADER * pevent, INT run_number, char *path)
00856
00857
00858
00859
00860
00861
00862
00863
00864
00865
00866
00867
00868
00869
00870
00871
00872 {
00873 INT dmpf, remaining;
00874 INT nread, filesize, nfrag;
00875 INT allheader_size;
00876 DWORD *pbuf, *pcfile, *pmy;
00877 YM_CFILE myc_fileh;
00878 YM_PFILE myp_fileh;
00879 int send_sock, flag;
00880
00881
00882
00883 if ((dmpf = open(path, O_RDONLY | O_BINARY | O_LARGEFILE, 0644)) == -1) {
00884 cm_msg(MINFO, "ybos_file_fragment", "File dump -Failure- on open file %s", path);
00885 return SS_FILE_ERROR;
00886 }
00887
00888
00889 filestat = (struct stat *) malloc(sizeof(struct stat));
00890 stat(path, filestat);
00891 filesize = filestat->st_size;
00892 free(filestat);
00893 cm_msg(MINFO, "ybos_file_fragment", "Accessing File %s (%i)", path, filesize);
00894
00895
00896 send_sock = rpc_get_send_sock();
00897
00898
00899 nfrag = filesize / MAX_FRAG_SIZE;
00900
00901
00902 srand((unsigned) time(NULL));
00903 srand((unsigned) time(NULL));
00904
00905
00906 myc_fileh.file_ID = rand();
00907 myc_fileh.size = filesize;
00908 myc_fileh.total_fragment = nfrag + (((filesize % MAX_FRAG_SIZE) == 0) ? 0 : 1);
00909 myc_fileh.current_fragment = 0;
00910 myc_fileh.current_read_byte = 0;
00911 myc_fileh.run_number = run_number;
00912 myc_fileh.spare = 0x1234abcd;
00913
00914
00915 memset(myp_fileh.path, 0, sizeof(YM_PFILE));
00916
00917 if (strrchr(path, '/') != NULL) {
00918 strncpy(myp_fileh.path, strrchr(path, '/') + 1, strlen(strrchr(path, '/')));
00919 } else
00920 strcpy(myp_fileh.path, path);
00921
00922
00923 allheader_size = sizeof(EVENT_HEADER)
00924 + sizeof(YBOS_BANK_HEADER)
00925 +5 * sizeof(DWORD)
00926 +sizeof(YM_CFILE)
00927 + sizeof(YM_PFILE) + 64;
00928
00929 flag = 0;
00930 pevent -= 1;
00931
00932
00933 while (myc_fileh.current_fragment <= nfrag) {
00934
00935 if (flag)
00936 pevent = dm_pointer_get();
00937 flag = 1;
00938
00939
00940 pmy = (DWORD *) (pevent + 1);
00941
00942
00943 if (eqp->format == FORMAT_YBOS)
00944 ybk_init((DWORD *) pmy);
00945 else if (eqp->format == FORMAT_MIDAS)
00946 bk_init(pmy);
00947
00948
00949 if (eqp->format == FORMAT_YBOS) {
00950 YBOS_EVID_BANK(pmy, myc_fileh.current_fragment,
00951 (eqp->info.event_id << 16) | (eqp->info.trigger_mask)
00952 , eqp->serial_number, run_number);
00953 } else if (eqp->format == FORMAT_MIDAS) {
00954 MIDAS_EVID_BANK(pmy, myc_fileh.current_fragment,
00955 (eqp->info.event_id << 16) | (eqp->info.trigger_mask)
00956 , eqp->serial_number, run_number);
00957 }
00958
00959
00960 if (eqp->format == FORMAT_YBOS)
00961 ybk_create(pmy, "CFIL", I4_BKTYPE, (DWORD *) & pbuf);
00962 else if (eqp->format == FORMAT_MIDAS)
00963 bk_create(pmy, "CFIL", TID_DWORD, &pbuf);
00964
00965
00966 pcfile = pbuf;
00967 pbuf = (DWORD *) (((char *) pbuf) + sizeof(YM_CFILE));
00968 if (eqp->format == FORMAT_YBOS)
00969 ybk_close(pmy, pbuf);
00970 else if (eqp->format == FORMAT_MIDAS)
00971 bk_close(pmy, pbuf);
00972
00973
00974 if (eqp->format == FORMAT_YBOS)
00975 ybk_create(pmy, "PFIL", A1_BKTYPE, (DWORD *) & pbuf);
00976 else if (eqp->format == FORMAT_MIDAS)
00977 bk_create(pmy, "PFIL", TID_CHAR, &pbuf);
00978 memcpy((char *) pbuf, (char *) &myp_fileh, sizeof(YM_PFILE));
00979 pbuf = (DWORD *) (((char *) pbuf) + sizeof(YM_CFILE));
00980 if (eqp->format == FORMAT_YBOS)
00981 ybk_close(pmy, pbuf);
00982 else if (eqp->format == FORMAT_MIDAS)
00983 bk_close(pmy, pbuf);
00984
00985
00986 if (eqp->format == FORMAT_YBOS)
00987 ybk_create(pmy, "DFIL", A1_BKTYPE, (DWORD *) & pbuf);
00988 else if (eqp->format == FORMAT_MIDAS)
00989 bk_create(pmy, "DFIL", TID_CHAR, (DWORD *) & pbuf);
00990
00991 remaining = filesize - myc_fileh.current_read_byte;
00992 nread =
00993 read(dmpf, (char *) pbuf,
00994 (remaining > MAX_FRAG_SIZE) ? MAX_FRAG_SIZE : remaining);
00995
00996 pbuf = (DWORD *) (((char *) pbuf) + nread);
00997
00998 myc_fileh.current_fragment++;
00999 myc_fileh.fragment_size = nread;
01000 myc_fileh.current_read_byte += nread;
01001 memcpy((char *) pcfile, (char *) &myc_fileh, sizeof(YM_CFILE));
01002
01003
01004 if (eqp->format == FORMAT_YBOS)
01005 ybk_close(pmy, pbuf);
01006 else if (eqp->format == FORMAT_MIDAS)
01007 bk_close(pmy, pbuf);
01008
01009
01010 if (eqp->format == FORMAT_YBOS)
01011 bm_compose_event(pevent, eqp->info.event_id,
01012 eqp->info.trigger_mask, ybk_size(pmy), eqp->serial_number++);
01013 else if (eqp->format == FORMAT_MIDAS)
01014 bm_compose_event(pevent, eqp->info.event_id,
01015 eqp->info.trigger_mask, bk_size(pmy), eqp->serial_number++);
01016
01017
01018 eqp->bytes_sent += pevent->data_size + sizeof(EVENT_HEADER);
01019 eqp->events_sent++;
01020 if (eqp->buffer_handle) {
01021
01022
01023
01024
01025
01026 #ifdef USE_EVENT_CHANNEL
01027 dm_pointer_increment(eqp->buffer_handle,
01028 pevent->data_size + sizeof(EVENT_HEADER));
01029 #else
01030 rpc_flush_event();
01031 bm_send_event(eqp->buffer_handle, pevent,
01032 pevent->data_size + sizeof(EVENT_HEADER), SYNC);
01033 #endif
01034 eqp->odb_out++;
01035 }
01036 }
01037
01038 if (close(dmpf)) {
01039 cm_msg(MERROR, "fe_file_dump", "cannot close file: %s", path);
01040 return SS_FILE_ERROR;
01041 }
01042 return YB_SUCCESS;
01043 }
01044
01045
01046 INT ybos_get_tid_size(INT tid)
01047 {
01048 if (tid < 8)
01049 return yb_tid_size[tid];
01050 return 0;
01051 }
01052
01053
01054
01055
01056
01057
01058 #if !defined (OS_VXWORKS)
01059
01060
01061
01062
01063
01064
01065 INT ybos_log_open(LOG_CHN * log_chn, INT run_number)
01066
01067
01068
01069
01070
01071
01072
01073
01074
01075
01076
01077 {
01078 YBOS_INFO *ybos;
01079 INT status;
01080
01081
01082 log_chn->format_info = (void **) malloc(sizeof(YBOS_INFO));
01083
01084 ybos = (YBOS_INFO *) log_chn->format_info;
01085
01086
01087 memset(ybos, 0, sizeof(YBOS_INFO));
01088
01089 if (ybos == NULL) {
01090 log_chn->handle = 0;
01091 return SS_NO_MEMORY;
01092 }
01093
01094
01095 if ((ybos->ptop = (DWORD *) malloc(YBOS_BUFFER_SIZE)) == NULL) {
01096 log_chn->handle = 0;
01097 return SS_NO_MEMORY;
01098 }
01099
01100 memset((char *) ybos->ptop, 0, YBOS_BUFFER_SIZE);
01101
01102 ybos->reco = YBOS_HEADER_LENGTH;
01103 ybos->pbuf = ybos->ptop + YBOS_HEADER_LENGTH;
01104 ybos->pwrt = ybos->pbuf;
01105 ybos->pbot = ybos->ptop + YBOS_PHYREC_SIZE;
01106 ybos->pend = ybos->ptop + YBOS_BUFFER_SIZE;
01107 ybos->recn = 0;
01108
01109 status = ybos_logfile_open(log_chn->type, log_chn->path, &log_chn->handle);
01110 if (status != SS_SUCCESS) {
01111 free(ybos->ptop);
01112 free(ybos);
01113 log_chn->handle = 0;
01114 return status;
01115 }
01116
01117
01118 if (log_chn->settings.odb_dump)
01119 ybos_log_dump(log_chn, EVENTID_BOR, run_number);
01120
01121 return SS_SUCCESS;
01122 }
01123
01124
01125 INT ybos_logfile_open(INT type, char *path, HNDLE * handle)
01126
01127
01128
01129
01130
01131
01132
01133
01134
01135
01136
01137
01138
01139
01140
01141
01142 {
01143 #ifdef YBOS_VERSION_3_3
01144 INT status;
01145 DWORD written;
01146 #endif
01147
01148
01149 if (type == LOG_TYPE_TAPE) {
01150
01151 return ss_tape_open(path, O_WRONLY | O_CREAT | O_TRUNC, handle);
01152 } else if (type == LOG_TYPE_DISK) {
01153 #ifdef OS_WINNT
01154 *handle =
01155 (int) CreateFile(path, GENERIC_WRITE, FILE_SHARE_READ, NULL,
01156 CREATE_ALWAYS,
01157 FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH
01158 | FILE_FLAG_SEQUENTIAL_SCAN, 0);
01159 #else
01160 *handle = open(path, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_LARGEFILE, 0644);
01161 #endif
01162 if (*handle < 0)
01163 return SS_FILE_ERROR;
01164 #ifdef YBOS_VERSION_3_3
01165
01166
01167 status = yb_any_dev_os_write(*handle, type, (char *) magta, 8, &written);
01168 if (status != SS_SUCCESS)
01169 return status;
01170
01171
01172 pbot = realloc(pbot, magta[2] - 4);
01173 memset((char *) pbot, 0, magta[2] - 4);
01174
01175 status = yb_any_dev_os_write(*handle, type, (char *) pbot, magta[2] - 4, &written);
01176 if (status != SS_SUCCESS)
01177 return status;
01178 #endif
01179 }
01180 return YB_SUCCESS;
01181 }
01182
01183
01184 INT ybos_write(LOG_CHN * log_chn, EVENT_HEADER * pevent, INT evt_size)
01185
01186
01187
01188
01189
01190
01191
01192
01193
01194
01195
01196
01197
01198
01199
01200
01201 {
01202 short int evid, evmsk;
01203 BOOL large_evt;
01204 INT status, left_over_length, datasize;
01205 YBOS_INFO *ybos;
01206 DWORD *pbkdat;
01207 DWORD bfsize;
01208 YBOS_PHYSREC_HEADER *yb_phrh;
01209
01210
01211
01212
01213
01214
01215 evid = pevent->event_id;
01216 evmsk = pevent->trigger_mask;
01217
01218
01219 ybos = (YBOS_INFO *) log_chn->format_info;
01220
01221
01222 if ((evid >= EVENTID_BOR) && (evid <= EVENTID_MESSAGE)) {
01223 if (!(evmsk & MT_USER))
01224 return SS_SUCCESS;
01225
01226
01227 if (MT_USER && !log_chn->settings.log_messages)
01228 return SS_SUCCESS;
01229
01230
01231
01232 if (pevent->data_size > MAX_EVENT_SIZE)
01233 cm_msg(MINFO, "ybos_write", "MMSG or MODB event too large");
01234
01235
01236 datasize = 4 * (pevent->data_size + 3) / 4;
01237
01238
01239 bfsize = datasize + sizeof(YBOS_BANK_HEADER) + 4;
01240
01241
01242 pbktop = (DWORD *) malloc(bfsize);
01243 if (pbktop == NULL) {
01244 cm_msg(MERROR, "ybos_write", "malloc error for ASCII dump");
01245 return SS_NO_MEMORY;
01246 }
01247 memset(pbktop, 0, bfsize);
01248 ybk_init(pbktop);
01249
01250
01251 if (evid == EVENTID_MESSAGE)
01252 ybk_create(pbktop, "MMSG", A1_BKTYPE, &pbkdat);
01253 else
01254 ybk_create(pbktop, "MODB", A1_BKTYPE, &pbkdat);
01255
01256 memcpy((char *) pbkdat, (char *) (pevent + 1), pevent->data_size);
01257 pbkdat = (DWORD *) (((char *) pbkdat) + datasize);
01258 ybk_close(pbktop, pbkdat);
01259
01260
01261 evt_size = ybk_size(pbktop);
01262
01263
01264 ybos_event_swap((DWORD *) pbktop);
01265
01266
01267 memcpy((char *) ybos->pbuf, (char *) pbktop, evt_size);
01268
01269 if (pbktop != NULL)
01270 free(pbktop);
01271 pbktop = NULL;
01272 status = SS_SUCCESS;
01273 } else {
01274
01275
01276
01277
01278
01279 pevent++;
01280
01281
01282 evt_size -= sizeof(EVENT_HEADER);
01283
01284
01285 ybos_event_swap((DWORD *) pevent);
01286
01287
01288 memcpy((char *) ybos->pbuf, (char *) pevent, evt_size);
01289
01290 status = YB_SUCCESS;
01291 }
01292
01293
01294 ybos->pbuf += (4 * (evt_size + 3) / 4) >> 2;
01295
01296
01297 large_evt = FALSE;
01298
01299
01300
01301 while (ybos->pbuf >= ybos->pbot) {
01302 ybos->pwrt -= YBOS_HEADER_LENGTH;
01303 yb_phrh = (YBOS_PHYSREC_HEADER *) (ybos->pwrt);
01304 yb_phrh->rec_size = YBOS_PHYREC_SIZE - 1;
01305 yb_phrh->header_length = YBOS_HEADER_LENGTH;
01306 yb_phrh->rec_num = ybos->recn;
01307 yb_phrh->offset = large_evt ? 0 : ybos->reco;
01308
01309
01310 status =
01311 yb_any_log_write(log_chn->handle, log_chn->format, log_chn->type,
01312 ybos->pwrt, YBOS_PHYREC_SIZE << 2);
01313 if (status != SS_SUCCESS)
01314 return status;
01315
01316
01317 #ifdef YBOS_VERSION_3_3
01318 if (log_chn->type == LOG_TYPE_TAPE) {
01319 log_chn->statistics.bytes_written += YBOS_PHYREC_SIZE << 2;
01320 log_chn->statistics.bytes_written_total += YBOS_PHYREC_SIZE << 2;
01321 } else {
01322 log_chn->statistics.bytes_written += YBOS_PHYREC_SIZE << 2 + 4;
01323 log_chn->statistics.bytes_written_total += YBOS_PHYREC_SIZE << 2 + 4;
01324 }
01325 #else
01326 log_chn->statistics.bytes_written += YBOS_PHYREC_SIZE << 2;
01327 log_chn->statistics.bytes_written_total += YBOS_PHYREC_SIZE << 2;
01328 #endif
01329
01330
01331 ybos->recn++;
01332
01333
01334 if (ybos->pbuf >= ybos->pbot + (YBOS_PHYREC_SIZE - YBOS_HEADER_LENGTH)) {
01335 large_evt = TRUE;
01336
01337 ybos->pwrt = ybos->pbot;
01338 ybos->pbot += (YBOS_PHYREC_SIZE - YBOS_HEADER_LENGTH);
01339 } else {
01340 large_evt = FALSE;
01341
01342 ybos->pwrt = ybos->ptop + YBOS_HEADER_LENGTH;
01343 left_over_length = ybos->pbuf - ybos->pbot;
01344 memcpy(ybos->pwrt, ybos->pbot, left_over_length << 2);
01345 ybos->pbuf = ybos->pwrt + left_over_length;
01346 ybos->pbot = ybos->ptop + YBOS_PHYREC_SIZE;
01347 ybos->reco = ybos->pbuf - ybos->pwrt + 4;
01348 }
01349 }
01350
01351
01352 log_chn->statistics.events_written++;
01353
01354 return status;
01355 }
01356
01357
01358 INT ybos_buffer_flush(LOG_CHN * log_chn, INT run_number)
01359
01360
01361
01362
01363
01364
01365
01366
01367
01368
01369
01370
01371 {
01372 INT status;
01373 YBOS_INFO *ybos;
01374 YBOS_PHYSREC_HEADER *yb_phrh;
01375
01376 ybos = (YBOS_INFO *) log_chn->format_info;
01377
01378
01379 if (log_chn->settings.odb_dump)
01380 ybos_log_dump(log_chn, EVENTID_EOR, run_number);
01381
01382
01383 ybos->pwrt -= YBOS_HEADER_LENGTH;
01384 yb_phrh = (YBOS_PHYSREC_HEADER *) ybos->pwrt;
01385
01386 yb_phrh->rec_size = YBOS_PHYREC_SIZE - 1;
01387 yb_phrh->header_length = YBOS_HEADER_LENGTH;
01388 yb_phrh->rec_num = ybos->recn;
01389 yb_phrh->offset = ybos->reco;
01390
01391
01392
01393
01394 memset((DWORD *) ybos->pbuf, -1, YBOS_PHYREC_SIZE << 2);
01395
01396
01397 status =
01398 yb_any_log_write(log_chn->handle, log_chn->format, log_chn->type,
01399 ybos->pwrt, YBOS_PHYREC_SIZE << 2);
01400 #ifdef YBOS_VERSION_3_3
01401 if (log_chn->type == LOG_TYPE_TAPE) {
01402 log_chn->statistics.bytes_written += YBOS_PHYREC_SIZE << 2;
01403 log_chn->statistics.bytes_written_total += YBOS_PHYREC_SIZE << 2;
01404 } else {
01405
01406 log_chn->statistics.bytes_written += YBOS_PHYREC_SIZE << 2 + 4;
01407 log_chn->statistics.bytes_written_total += YBOS_PHYREC_SIZE << 2 + 4;
01408 }
01409 #else
01410 log_chn->statistics.bytes_written += YBOS_PHYREC_SIZE << 2;
01411 log_chn->statistics.bytes_written_total += YBOS_PHYREC_SIZE << 2;
01412 #endif
01413 return status;
01414 }
01415
01416
01417 INT ybos_logfile_close(INT type, HNDLE handle)
01418
01419
01420
01421
01422
01423
01424
01425
01426
01427
01428
01429
01430
01431
01432 {
01433 INT status;
01434
01435 if (type == LOG_TYPE_TAPE) {
01436
01437 status = ss_tape_write_eof(handle);
01438 #ifdef OS_UNIX
01439 if (status != SS_SUCCESS) {
01440 if (errno == EIO)
01441 return SS_IO_ERROR;
01442 if (errno == ENOSPC)
01443 return SS_NO_SPACE;
01444 else
01445 return status;
01446 }
01447 #endif
01448 #ifdef OS_WINNT
01449 if (status != SS_SUCCESS) {
01450 if (errno == ERROR_END_OF_MEDIA)
01451 return SS_NO_SPACE;
01452 else
01453 return status;
01454 }
01455 #endif
01456
01457 ss_tape_close(handle);
01458 } else if (type == LOG_TYPE_DISK) {
01459 #ifdef OS_WINNT
01460 CloseHandle((HANDLE) handle);
01461 #else
01462 close(handle);
01463 #endif
01464 }
01465 return YB_SUCCESS;
01466 }
01467
01468
01469
01470 INT ybos_log_close(LOG_CHN * log_chn, INT run_number)
01471
01472
01473
01474
01475
01476
01477
01478
01479
01480
01481
01482 {
01483 INT status;
01484 YBOS_INFO *ybos;
01485
01486 ybos = (YBOS_INFO *) log_chn->format_info;
01487
01488
01489
01490 status = ybos_buffer_flush(log_chn, run_number);
01491
01492 if (status != SS_SUCCESS)
01493 return status;
01494
01495 status = ybos_logfile_close(log_chn->type, log_chn->handle);
01496
01497 free(ybos->ptop);
01498 free(ybos);
01499
01500 return SS_SUCCESS;
01501 }
01502
01503
01504 void ybos_log_dump(LOG_CHN * log_chn, short int event_id, INT run_number)
01505
01506
01507
01508
01509
01510
01511
01512
01513
01514
01515
01516
01517
01518
01519
01520
01521 {
01522 INT status, buffer_size, size;
01523 EVENT_HEADER *pevent;
01524 HNDLE hDB;
01525
01526 cm_get_experiment_database(&hDB, NULL);
01527
01528 buffer_size = 10000;
01529 do {
01530 pevent = (EVENT_HEADER *) malloc(buffer_size);
01531 if (pevent == NULL) {
01532 cm_msg(MERROR, "ybos_odb_log_dump", "Cannot allocate ODB dump buffer");
01533 break;
01534 }
01535
01536 size = buffer_size - sizeof(EVENT_HEADER);
01537 status = db_copy(hDB, 0, (char *) (pevent + 1), &size, "");
01538 if (status != DB_TRUNCATED) {
01539 bm_compose_event(pevent, event_id, MIDAS_MAGIC,
01540 buffer_size - sizeof(EVENT_HEADER) - size + 1, run_number);
01541 ybos_write(log_chn, pevent, pevent->data_size + sizeof(EVENT_HEADER));
01542 break;
01543 }
01544
01545
01546 free(pevent);
01547 buffer_size *= 2;
01548 } while (1);
01549 free(pevent);
01550 }
01551
01552
01553
01554
01555
01556
01557
01558 INT yb_any_file_ropen(char *infile, INT data_fmt)
01559
01560
01561
01562
01563
01564
01565
01566
01567
01568
01569
01570
01571 {
01572 INT status;
01573
01574
01575 strcpy(my.name, infile);
01576
01577
01578 my.zipfile = FALSE;
01579 if ((strncmp(my.name, "/dev", 4) == 0) || (strncmp(my.name, "\\\\.\\", 4) == 0)) {
01580
01581 my.type = LOG_TYPE_TAPE;
01582 } else {
01583
01584 my.type = LOG_TYPE_DISK;
01585 if (strncmp(infile + strlen(infile) - 3, ".gz", 3) == 0)
01586 my.zipfile = TRUE;
01587 }
01588
01589
01590 if (!my.zipfile) {
01591 if (my.type == LOG_TYPE_TAPE) {
01592 status = ss_tape_open(my.name, O_RDONLY | O_BINARY, &my.handle);
01593 }
01594 else if ((my.handle = open(my.name, O_RDONLY | O_BINARY | O_LARGEFILE, 0644)) == -1)
01595 {
01596 printf("dev name :%s Handle:%d \n", my.name, my.handle);
01597 return (SS_FILE_ERROR);
01598 }
01599 } else {
01600 #ifdef INCLUDE_ZLIB
01601 if (my.type == LOG_TYPE_TAPE) {
01602 printf(" Zip on tape not yet supported \n");
01603 return (SS_FILE_ERROR);
01604 }
01605 filegz = gzopen(my.name, "rb");
01606 my.handle = 0;
01607 if (filegz == NULL) {
01608 printf("dev name :%s gzopen error:%d \n", my.name, my.handle);
01609 return (SS_FILE_ERROR);
01610 }
01611 #else
01612 cm_msg(MERROR, "ybos.c", "Zlib not included ... gz file not supported");
01613 return (SS_FILE_ERROR);
01614 #endif
01615 }
01616
01617 if (data_fmt == FORMAT_YBOS) {
01618 my.fmt = FORMAT_YBOS;
01619 my.size = YBOS_PHYREC_SIZE;
01620 my.pmagta = (char *) malloc(32);
01621 if (my.pmagta == NULL)
01622 return SS_NO_MEMORY;
01623 my.pyh = (YBOS_PHYSREC_HEADER *) malloc(my.size * 14);
01624 if (my.pyh == NULL)
01625 return SS_NO_MEMORY;
01626 (my.pyh)->rec_size = my.size - 1;
01627 (my.pyh)->header_length = YBOS_HEADER_LENGTH;
01628 (my.pyh)->rec_num = 0;
01629 (my.pyh)->offset = 0;
01630
01631 my.pyrd = (DWORD *) ((DWORD *) my.pyh + (my.pyh)->offset);
01632
01633
01634 my.pylrl = (DWORD *) malloc(MAX_EVENT_SIZE);
01635 if (my.pylrl == NULL)
01636 return SS_NO_MEMORY;
01637 memset((char *) my.pylrl, -1, MAX_EVENT_SIZE);
01638
01639
01640 my.magtafl = FALSE;
01641 } else if (data_fmt == FORMAT_MIDAS) {
01642 my.fmt = FORMAT_MIDAS;
01643 my.size = TAPE_BUFFER_SIZE;
01644 my.pmp = (char *) malloc(my.size);
01645 if (my.pmp == NULL)
01646 return SS_NO_MEMORY;
01647 my.pme = (EVENT_HEADER *) my.pmp;
01648
01649
01650 if (my.pmrd != NULL)
01651 free(my.pmrd);
01652 my.pmrd = (char *) malloc(5 * MAX_EVENT_SIZE);
01653 ptopmrd = my.pmrd;
01654 if (my.pmrd == NULL)
01655 return SS_NO_MEMORY;
01656 memset((char *) my.pmrd, -1, 5 * MAX_EVENT_SIZE);
01657 my.pmh = (EVENT_HEADER *) my.pmrd;
01658 }
01659
01660
01661 my.recn = (DWORD) - 1;
01662 my.evtn = 0;
01663 return (YB_SUCCESS);
01664 }
01665
01666
01667 INT yb_any_file_rclose(INT data_fmt)
01668
01669
01670
01671
01672
01673
01674
01675
01676
01677
01678 {
01679 switch (my.type) {
01680 case LOG_TYPE_TAPE:
01681 case LOG_TYPE_DISK:
01682
01683 if (my.zipfile) {
01684 #ifdef INCLUDE_ZLIB
01685 gzclose(filegz);
01686 #endif
01687 } else {
01688 if (my.handle != 0)
01689 close(my.handle);
01690 }
01691 break;
01692 }
01693 if (my.pmagta != NULL)
01694 free(my.pmagta);
01695 if (my.pyh != NULL)
01696 free(my.pyh);
01697 if (my.pylrl != NULL)
01698 free(my.pylrl);
01699 if (ptopmrd != NULL)
01700 free(ptopmrd);
01701 if (my.pmp != NULL)
01702 free(my.pmp);
01703 my.pylrl = NULL;
01704 my.pyh = NULL;
01705 my.pmagta = NULL;
01706 my.pmp = NULL;
01707 my.pmh = NULL;
01708 ptopmrd = NULL;
01709 return (YB_SUCCESS);
01710 }
01711
01712 #ifdef INCLUDE_FTPLIB
01713
01714
01715 INT yb_ftp_open(char *destination, FTP_CON ** con)
01716 {
01717 INT status;
01718 short port = 0;
01719 char *token, host_name[HOST_NAME_LENGTH],
01720 user[32], pass[32], directory[256], file_name[256], file_mode[256];
01721
01722
01723
01724
01725
01726
01727
01728 token = strtok(destination, ",");
01729 if (token)
01730 strcpy(host_name, token);
01731
01732 token = strtok(NULL, ", ");
01733 if (token)
01734 port = atoi(token);
01735
01736 token = strtok(NULL, ", ");
01737 if (token)
01738 strcpy(user, token);
01739
01740 token = strtok(NULL, ", ");
01741 if (token)
01742 strcpy(pass, token);
01743
01744 token = strtok(NULL, ", ");
01745 if (token)
01746 strcpy(directory, token);
01747
01748 token = strtok(NULL, ", ");
01749 if (token)
01750 strcpy(file_name, token);
01751
01752 token = strtok(NULL, ", ");
01753 file_mode[0] = 0;
01754 if (token)
01755 strcpy(file_mode, token);
01756
01757 status = ftp_login(con, host_name, port, user, pass, "");
01758 if (status >= 0)
01759 return status;
01760
01761 status = ftp_chdir(*con, directory);
01762 if (status >= 0)
01763 return status;
01764
01765 status = ftp_binary(*con);
01766 if (status >= 0)
01767 return status;
01768
01769 if (file_mode[0]) {
01770 status = ftp_command(*con, "umask %s", file_mode, 200, 250, EOF);
01771 if (status >= 0)
01772 return status;
01773 }
01774
01775 if (ftp_open_write(*con, file_name) >= 0)
01776 return (*con)->err_no;
01777
01778 return SS_SUCCESS;
01779 }
01780
01781
01782 #endif
01783
01784
01785 INT yb_any_file_wopen(INT type, INT data_fmt, char *filename, INT * hDev)
01786
01787
01788
01789
01790
01791
01792
01793
01794
01795
01796
01797
01798 {
01799 INT status = 0;
01800
01801 if (type == LOG_TYPE_DISK)
01802
01803 {
01804 if (data_fmt == FORMAT_YBOS) {
01805
01806 status = ybos_logfile_open(type, filename, hDev);
01807 } else if (data_fmt == FORMAT_MIDAS) {
01808 #ifdef OS_WINNT
01809 *hDev =
01810 (int) CreateFile(filename, GENERIC_WRITE, FILE_SHARE_READ,
01811 NULL, CREATE_ALWAYS,
01812 FILE_ATTRIBUTE_NORMAL |
01813 FILE_FLAG_WRITE_THROUGH | FILE_FLAG_SEQUENTIAL_SCAN, 0);
01814 #else
01815 *hDev = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_LARGEFILE, 0644);
01816 #endif
01817 status = *hDev < 0 ? SS_FILE_ERROR : SS_SUCCESS;
01818 }
01819 } else if (type == LOG_TYPE_TAPE) {
01820 if (data_fmt == FORMAT_YBOS) {
01821
01822 status = ybos_logfile_open(type, filename, hDev);
01823 } else if (data_fmt == FORMAT_MIDAS)
01824 status = ss_tape_open(filename, O_WRONLY | O_CREAT | O_TRUNC, hDev);
01825 } else if (type == LOG_TYPE_FTP) {
01826 #ifdef INCLUDE_FTPLIB
01827 status = yb_ftp_open(filename, (FTP_CON **) & ftp_con);
01828 if (status != SS_SUCCESS) {
01829 *hDev = 0;
01830 return status;
01831 } else
01832 *hDev = 1;
01833 #else
01834 cm_msg(MERROR, "yb_any_file_wopen", "FTP support not included");
01835 return SS_FILE_ERROR;
01836 #endif
01837 }
01838
01839 return status;
01840 }
01841
01842
01843 INT yb_any_file_wclose(INT handle, INT type, INT data_fmt)
01844
01845
01846
01847
01848
01849
01850
01851
01852
01853
01854 {
01855 INT status;
01856 status = SS_SUCCESS;
01857 switch (type) {
01858 case LOG_TYPE_TAPE:
01859
01860 status = ss_tape_write_eof(handle);
01861 ss_tape_close(handle);
01862 break;
01863 case LOG_TYPE_DISK:
01864
01865 if (handle != 0)
01866 #ifdef OS_WINNT
01867 CloseHandle((HANDLE) handle);
01868 #else
01869 close(handle);
01870 #endif
01871 break;
01872 case LOG_TYPE_FTP:
01873 #ifdef INCLUDE_FTPLIB
01874 ftp_close(ftp_con);
01875 ftp_bye(ftp_con);
01876 #endif
01877 break;
01878 }
01879 if (status != SS_SUCCESS)
01880 return status;
01881 return (YB_SUCCESS);
01882 }
01883
01884
01885 INT yb_any_dev_os_read(INT handle, INT type, void *prec, DWORD nbytes, DWORD * readn)
01886
01887
01888
01889
01890
01891
01892
01893
01894
01895
01896
01897
01898
01899
01900 {
01901 INT status;
01902 if (type == LOG_TYPE_DISK)
01903
01904 {
01905 *readn = read(handle, prec, nbytes);
01906 if (*readn <= 0)
01907 status = SS_FILE_ERROR;
01908 else
01909 status = SS_SUCCESS;
01910 return status;
01911 }
01912
01913 #ifdef OS_UNIX
01914 else if (type == LOG_TYPE_TAPE) {
01915 *readn = read(handle, prec, nbytes);
01916 if (*readn <= 0)
01917 status = SS_FILE_ERROR;
01918 else
01919 status = SS_SUCCESS;
01920 return status;
01921 }
01922 #endif
01923
01924 #ifdef OS_WINNT
01925 else if (type == LOG_TYPE_TAPE) {
01926 if (!ReadFile((HANDLE) handle, prec, nbytes, readn, NULL))
01927 status = GetLastError();
01928 else
01929 status = SS_SUCCESS;
01930 if (status == ERROR_NO_DATA_DETECTED)
01931 status = SS_END_OF_TAPE;
01932
01933 return status;
01934 }
01935 #endif
01936 else
01937 return SS_SUCCESS;
01938 }
01939
01940
01941 INT yb_any_dev_os_write(INT handle, INT type, void *prec, DWORD nbytes, DWORD * written)
01942
01943
01944
01945
01946
01947
01948
01949
01950
01951
01952
01953
01954
01955
01956
01957
01958 {
01959 INT status;
01960 if (type == LOG_TYPE_DISK)
01961 #ifdef OS_WINNT
01962 {
01963 WriteFile((HANDLE) handle, (char *) prec, nbytes, written, NULL);
01964 status = *written == nbytes ? SS_SUCCESS : SS_FILE_ERROR;
01965 return status;
01966 }
01967 #else
01968 {
01969 status = *written =
01970 write(handle, (char *) prec, nbytes) == nbytes ? SS_SUCCESS : SS_FILE_ERROR;
01971 return status;
01972 }
01973 #endif
01974 else if (type == LOG_TYPE_TAPE) {
01975 #ifdef OS_UNIX
01976 do {
01977 status = write(handle, (char *) prec, nbytes);
01978 } while (status == -1 && errno == EINTR);
01979 *written = status;
01980 if (*written != nbytes) {
01981 cm_msg(MERROR, "any_dev_os_write", strerror(errno));
01982 if (errno == EIO)
01983 return SS_IO_ERROR;
01984 if (errno == ENOSPC)
01985 return SS_NO_SPACE;
01986 else
01987 return SS_TAPE_ERROR;
01988 }
01989 #endif
01990
01991 #ifdef OS_WINNT
01992 WriteFile((HANDLE) handle, (char *) prec, nbytes, written, NULL);
01993 if (*written != nbytes) {
01994 status = GetLastError();
01995 cm_msg(MERROR, "any_dev_os_write", "error %d", status);
01996 return SS_IO_ERROR;
01997 }
01998 return SS_SUCCESS;
01999 #endif
02000 } else if (type == LOG_TYPE_FTP)
02001 #ifdef INCLUDE_FTPLIB
02002 {
02003 *written =
02004 (DWORD) status =
02005 (INT) ftp_send(ftp_con->data, (char *) prec,
02006 (int) nbytes) == (int) nbytes ? SS_SUCCESS : SS_FILE_ERROR;
02007 return status;
02008 }
02009 #else
02010 {
02011 cm_msg(MERROR, "ybos", "FTP support not included");
02012 return SS_IO_ERROR;
02013 }
02014 #endif
02015 return SS_SUCCESS;
02016 }
02017
02018
02019 INT yb_any_physrec_get(INT data_fmt, void **precord, DWORD * readn)
02020
02021
02022
02023
02024
02025
02026
02027
02028
02029
02030
02031 {
02032 *precord = my.pmp;
02033 if (data_fmt == FORMAT_MIDAS)
02034 return midas_physrec_get(*precord, readn);
02035 else if (data_fmt == FORMAT_YBOS)
02036 return ybos_physrec_get((DWORD **) precord, readn);
02037 else
02038 return YB_UNKNOWN_FORMAT;
02039 }
02040
02041
02042 INT ybos_physrec_get(DWORD ** precord, DWORD * readn)
02043
02044
02045
02046
02047
02048
02049
02050
02051
02052
02053
02054
02055
02056
02057
02058 {
02059 INT status;
02060
02061 #ifdef YBOS_VERSION_3_3
02062 if (my.magtafl) {
02063
02064 if (!my.zipfile) {
02065 status = yb_any_dev_os_read(my.handle, my.type, my.pmagta, 4, readn);
02066 if (status != SS_SUCCESS)
02067 return (YB_DONE);
02068 } else {
02069 #ifdef INCLUDE_ZLIB
02070 status = gzread(filegz, (char *) my.pmagta, 4);
02071 if (status <= 0)
02072 return (YB_DONE);
02073 #endif
02074 }
02075 }
02076 #endif
02077
02078
02079 if (!my.zipfile) {
02080 status = yb_any_dev_os_read(my.handle, my.type, my.pyh, my.size << 2, readn);
02081 if (status != SS_SUCCESS)
02082 return (YB_DONE);
02083 } else {
02084 #ifdef INCLUDE_ZLIB
02085 status = gzread(filegz, (char *) my.pyh, my.size << 2);
02086 if (status <= 0)
02087 return (YB_DONE);
02088 #endif
02089 }
02090
02091 #ifdef YBOS_VERSION_3_3
02092
02093 if ((!my.magtafl) && (*((DWORD *) my.pyh) == 0x00000004)) {
02094
02095 my.magtafl = TRUE;
02096
02097 if (!my.zipfile) {
02098 status = yb_any_dev_os_read(my.handle, my.type, my.pmagta, 8, readn);
02099 if (status != SS_SUCCESS)
02100 return (YB_DONE);
02101 } else {
02102 #ifdef INCLUDE_ZLIB
02103 status = gzread(filegz, (char *) my.pmagta, 8);
02104 if (status <= 0)
02105 return (YB_DONE);
02106 #endif
02107 }
02108
02109
02110 if (!my.zipfile) {
02111 status = yb_any_dev_os_read(my.handle, my.type, my.pyh, my.size << 2, readn);
02112 if (status != SS_SUCCESS)
02113 return (YB_DONE);
02114 } else {
02115 #ifdef INCLUDE_ZLIB
02116 status = gzread(filegz, (char *) my.pyh, my.size << 2);
02117 if (status <= 0)
02118 return (YB_DONE);
02119 #endif
02120 }
02121 }
02122 #endif
02123
02124
02125 if ((my.pyh)->offset == 0) {
02126
02127
02128 my.pyrd = (DWORD *) my.pyh + (my.pyh)->offset;
02129 } else {
02130
02131
02132 my.pyrd = (DWORD *) my.pyh + (my.pyh)->offset;
02133 }
02134
02135 my.recn++;
02136
02137 *precord = (DWORD *) (my.pyh);
02138
02139 return (YB_SUCCESS);
02140 }
02141
02142
02143 INT midas_physrec_get(void *prec, DWORD * readn)
02144
02145
02146
02147
02148
02149
02150
02151
02152
02153
02154
02155
02156
02157
02158
02159
02160
02161 {
02162 INT status = 0;
02163
02164
02165 if (!my.zipfile) {
02166 status = yb_any_dev_os_read(my.handle, my.type, prec, my.size, readn);
02167 } else {
02168 #ifdef INCLUDE_ZLIB
02169 *readn = gzread(filegz, (char *) prec, my.size);
02170 if (*readn <= 0)
02171 status = SS_FILE_ERROR;
02172 else
02173 status = SS_SUCCESS;
02174 #endif
02175 }
02176
02177 if (status != SS_SUCCESS) {
02178 return (YB_DONE);
02179 } else {
02180
02181 my.recn++;
02182 return (YB_SUCCESS);
02183 }
02184 }
02185
02186
02187 INT yb_any_log_write(INT handle, INT data_fmt, INT type, void *prec, DWORD nbytes)
02188
02189
02190
02191
02192
02193
02194
02195
02196
02197
02198
02199
02200
02201
02202
02203
02204 {
02205 INT status;
02206 DWORD written;
02207
02208 #ifdef YBOS_VERSION_3_3
02209 if ((type == LOG_TYPE_DISK) && (data_fmt == FORMAT_YBOS)) {
02210 status =
02211 yb_any_dev_os_write(handle, type,
02212 (char *) ((DWORD *) (magta + 2)), 4, &written);
02213 if (status != SS_SUCCESS)
02214 return status;
02215 }
02216 #endif
02217
02218 status = yb_any_dev_os_write(handle, type, prec, nbytes, &written);
02219 return status;
02220 }
02221
02222
02223 INT yb_any_physrec_skip(INT data_fmt, INT bl)
02224
02225
02226
02227
02228
02229
02230
02231
02232
02233
02234
02235
02236
02237
02238 {
02239 INT status;
02240
02241 if (data_fmt == FORMAT_MIDAS) {
02242 status = midas_event_skip(bl);
02243 return YB_SUCCESS;
02244 } else if (data_fmt == FORMAT_YBOS)
02245 return ybos_physrec_skip(bl);
02246 else
02247 return YB_UNKNOWN_FORMAT;
02248 }
02249
02250
02251 INT ybos_physrec_skip(INT bl)
02252
02253
02254
02255
02256
02257
02258
02259
02260
02261
02262
02263
02264 {
02265 INT status;
02266 DWORD *prec, size;
02267
02268 if (bl == -1) {
02269 if ((status = ybos_physrec_get(&prec, &size)) == YB_SUCCESS)
02270 return status;
02271 }
02272 while (ybos_physrec_get(&prec, &size) == YB_SUCCESS) {
02273 if ((INT) (my.pyh)->rec_num != bl) {
02274 printf("Skipping physical record_# ... ");
02275 printf("%ld \r", (my.pyh)->rec_num);
02276 fflush(stdout);
02277 } else {
02278 printf("\n");
02279 return YB_SUCCESS;
02280 }
02281 }
02282 return YB_DONE;
02283 }
02284
02285
02286 INT midas_event_skip(INT evtn)
02287
02288
02289
02290
02291
02292
02293
02294
02295
02296
02297
02298 {
02299 void *pevent;
02300 DWORD size;
02301
02302 size = MAX_EVENT_SIZE;
02303 if (evtn == -1) {
02304
02305 return YB_SUCCESS;
02306 }
02307 while (midas_event_get(&pevent, &size) == YB_SUCCESS) {
02308 if ((INT) my.evtn < evtn) {
02309 printf("Skipping event_# ... ");
02310 printf("%ld \r", my.evtn);
02311 fflush(stdout);
02312 } else {
02313 printf("\n");
02314 return YB_SUCCESS;
02315 }
02316 }
02317 return YB_DONE;
02318 }
02319
02320
02321 INT yb_any_physrec_display(INT data_fmt)
02322
02323
02324
02325
02326
02327
02328
02329
02330
02331
02332
02333
02334 {
02335 INT bz, j, i, k;
02336 DWORD *prec;
02337
02338 if (data_fmt == FORMAT_MIDAS) {
02339 printf(">>> No physical record structure for Midas format <<<\n");
02340 return YB_DONE;
02341 } else if (data_fmt == FORMAT_YBOS) {
02342 yb_any_all_info_display(D_RECORD);
02343 bz = (my.pyh)->rec_size + 1;
02344
02345 prec = (DWORD *) (my.pyh);
02346 k = (my.pyh)->rec_num;
02347 for (i = 0; i < bz; i += NLINE) {
02348 printf("R(%d)[%d] = ", k, i);
02349 for (j = 0; j < NLINE; j++) {
02350 if (i + j < bz) {
02351 printf("%8.8lx ", *prec);
02352 prec++;
02353 }
02354 }
02355 printf("\n");
02356 }
02357 return (YB_SUCCESS);
02358 } else
02359 return YB_UNKNOWN_FORMAT;
02360 }
02361
02362
02363 INT yb_any_all_info_display(INT what)
02364
02365
02366
02367
02368
02369
02370
02371
02372
02373
02374
02375 {
02376 if (my.fmt == FORMAT_YBOS) {
02377 DWORD bz, hyl, ybn, of;
02378
02379 bz = (my.pyh)->rec_size;
02380 hyl = (my.pyh)->header_length;
02381 ybn = (my.pyh)->rec_num;
02382 of = (my.pyh)->offset;
02383 switch (what) {
02384 case D_RECORD:
02385 case D_HEADER:
02386 printf("rec#%ld- ", my.recn);
02387 printf("%5ldbz %5ldhyl %5ldybn %5ldof\n", bz, hyl, ybn, of);
02388 break;
02389 case D_EVTLEN:
02390 printf("rec#%ld- ", my.recn);
02391 printf("%5ldbz %5ldhyl %5ldybn %5ldof ", bz, hyl, ybn, of);
02392 printf("%5ldel/x%lx %5ldev\n", my.evtlen, my.evtlen, my.evtn);
02393 break;
02394 }
02395 } else if (my.fmt == FORMAT_MIDAS) {
02396 DWORD mbn, run, ser;
02397 WORD id, msk;
02398 mbn = my.evtn;
02399 run = my.runn;
02400 id = my.pmh->event_id;
02401 msk = my.pmh->trigger_mask;
02402 ser = my.pmh->serial_number;
02403 switch (what) {
02404 case D_RECORD:
02405 case D_HEADER:
02406 printf(">>> No physical record structure for Midas format <<<\n");
02407 return YB_DONE;
02408 break;
02409 case D_EVTLEN:
02410 printf("Evt#%ld- ", my.evtn);
02411 printf("%lirun 0x%4.4uxid 0x%4.4uxmsk %5ldmevt#", run, id, msk, mbn);
02412 printf("%5ldel/x%lx %5ldserial\n", my.evtlen, my.evtlen, ser);
02413 break;
02414 }
02415 }
02416 return YB_SUCCESS;
02417 }
02418
02419
02420 INT yb_any_event_swap(INT data_fmt, void *pevent)
02421
02422
02423
02424
02425
02426
02427
02428
02429
02430
02431
02432 {
02433 INT status;
02434 BANK_HEADER *pbh;
02435
02436 if (data_fmt == FORMAT_MIDAS) {
02437 if ((((EVENT_HEADER *) pevent)->event_id == EVENTID_BOR) ||
02438 (((EVENT_HEADER *) pevent)->event_id == EVENTID_EOR) ||
02439 (((EVENT_HEADER *) pevent)->event_id == EVENTID_MESSAGE))
02440 return SS_SUCCESS;
02441 pbh = (BANK_HEADER *) (((EVENT_HEADER *) pevent) + 1);
02442 status = bk_swap(pbh, FALSE);
02443 return status == CM_SUCCESS ? YB_EVENT_NOT_SWAPPED : YB_SUCCESS;
02444 } else if (data_fmt == FORMAT_YBOS) {
02445 status = ybos_event_swap((DWORD *) pevent);
02446 return status == YB_EVENT_NOT_SWAPPED ? YB_SUCCESS : status;
02447 }
02448
02449 return YB_UNKNOWN_FORMAT;
02450 }
02451
02452
02453 INT ybos_event_swap(DWORD * plrl)
02454
02455
02456
02457
02458
02459
02460
02461
02462
02463
02464
02465
02466
02467
02468 {
02469 DWORD *pevt, *pnextb, *pendevt;
02470 DWORD bank_length, bank_type;
02471
02472
02473 if ((((YBOS_BANK_HEADER *) (plrl + 1))->type) < MAX_BKTYPE)
02474 return (YB_EVENT_NOT_SWAPPED);
02475
02476
02477 DWORD_SWAP(plrl);
02478 pevt = plrl + 1;
02479
02480
02481 pendevt = pevt + *plrl;
02482
02483
02484 while (pevt < pendevt) {
02485
02486
02487 pevt++;
02488
02489 DWORD_SWAP(pevt);
02490 pevt++;
02491
02492 DWORD_SWAP(pevt);
02493 pevt++;
02494
02495 DWORD_SWAP(pevt);
02496 bank_length = *pevt++;
02497
02498 DWORD_SWAP(pevt);
02499 bank_type = *pevt++;
02500
02501
02502
02503
02504 pnextb = pevt + bank_length - 1;
02505
02506 switch (bank_type) {
02507 case D8_BKTYPE:
02508 while ((BYTE *) pevt < (BYTE *) pnextb) {
02509 QWORD_SWAP(pevt);
02510 pevt = (DWORD *) (((double *) pevt) + 1);
02511 }
02512 break;
02513 case I4_BKTYPE:
02514 case F4_BKTYPE:
02515 while ((BYTE *) pevt < (BYTE *) pnextb) {
02516 DWORD_SWAP(pevt);
02517 pevt++;
02518 }
02519 break;
02520 case I2_BKTYPE:
02521 while ((BYTE *) pevt < (BYTE *) pnextb) {
02522 WORD_SWAP(pevt);
02523 pevt = (DWORD *) (((WORD *) pevt) + 1);
02524 }
02525 break;
02526 case I1_BKTYPE:
02527 case A1_BKTYPE:
02528 pevt = pnextb;
02529 break;
02530 default:
02531 printf("ybos_swap_event-E- Unknown bank type %li\n", bank_type);
02532 return (YB_SWAP_ERROR);
02533 break;
02534 }
02535 }
02536 return (YB_SUCCESS);
02537 }
02538
02539
02540 INT yb_any_event_get(INT data_fmt, void **pevent, DWORD * readn)
02541
02542
02543
02544
02545
02546
02547
02548
02549
02550
02551
02552 {
02553 INT status = 0;
02554
02555 *pevent = NULL;
02556 if (data_fmt == FORMAT_MIDAS)
02557 status = midas_event_get(pevent, readn);
02558 else if (data_fmt == FORMAT_YBOS)
02559 status = ybos_event_get((DWORD **) pevent, readn);
02560 return (status);
02561 }
02562
02563
02564 INT ybos_event_get(DWORD ** plrl, DWORD * readn)
02565
02566
02567
02568
02569
02570
02571
02572
02573
02574
02575
02576
02577 {
02578 DWORD size, fpart, lpart, evt_length;
02579 DWORD *ptmp, *prec;
02580 INT status;
02581
02582
02583
02584 if ((INT) (*my.pyrd) == -1)
02585 return YB_DONE;
02586
02587
02588
02589 evt_length = *(my.pyrd) + 1;
02590 memcpy((char *) my.pylrl, (char *) my.pyrd, evt_length << 2);
02591
02592
02593
02594
02595
02596 if (evt_length - 1 == -1)
02597 return (YB_DONE);
02598
02599
02600 if ((my.pyrd + evt_length) >= (DWORD *) my.pyh + my.size) {
02601
02602
02603 fpart = (DWORD *) my.pyh + my.size - my.pyrd;
02604 memcpy((char *) my.pylrl, (char *) my.pyrd, fpart << 2);
02605
02606
02607 ptmp = my.pylrl + fpart;
02608
02609 if ((evt_length - fpart) == 0) {
02610
02611 if ((status = ybos_physrec_get(&prec, &size)) != YB_SUCCESS)
02612 return (status);
02613 my.pyrd = (DWORD *) my.pyh + my.pyh->header_length;
02614 } else {
02615 while ((evt_length - fpart) > 0) {
02616 lpart = evt_length - fpart;
02617 if (lpart > (YBOS_PHYREC_SIZE - YBOS_HEADER_LENGTH))
02618 lpart = (YBOS_PHYREC_SIZE - YBOS_HEADER_LENGTH);
02619
02620
02621 if ((status = ybos_physrec_get(&prec, &size)) != YB_SUCCESS)
02622 return (status);
02623
02624
02625
02626
02627 my.pyrd = (DWORD *) my.pyh + my.pyh->header_length;
02628
02629 memcpy((char *) ptmp, (char *) my.pyrd, lpart << 2);
02630
02631
02632
02633 my.pyrd += lpart;
02634 fpart += lpart;
02635 ptmp += lpart;
02636 }
02637 }
02638 if (my.pyrd != (DWORD *) my.pyh + my.pyh->offset) {
02639 printf(" event misalignment !! %p %p \n",
02640 my.pyrd, (DWORD *) my.pyh + my.pyh->offset);
02641 printf("Event crossed boundary: length %ld\n", evt_length);
02642 my.pyrd = (DWORD *) my.pyh + my.pyh->offset;
02643 }
02644
02645 } else {
02646
02647 my.pyrd += evt_length;
02648 }
02649
02650 my.evtn++;
02651
02652
02653 my.evtlen = evt_length;
02654
02655 *readn = my.evtlen << 2;
02656 *plrl = (DWORD *) my.pylrl;
02657 return (YB_SUCCESS);
02658 }
02659
02660
02661 INT midas_event_get(void **pevent, DWORD * readn)
02662
02663
02664
02665
02666
02667
02668
02669
02670
02671
02672
02673
02674
02675
02676
02677
02678 {
02679 INT status, leftover;
02680 DWORD fpart;
02681 static DWORD size = 0;
02682
02683
02684 *pevent = (char *) my.pmh;
02685 if (size == 0)
02686 size = my.size;
02687
02688
02689 if (my.recn == -1) {
02690 status = midas_physrec_get((void *) my.pmp, &size);
02691 if (status != YB_SUCCESS)
02692 return (YB_DONE);
02693 }
02694
02695
02696
02697
02698
02699
02700
02701 if (((my.pmp + size) - (char *) my.pme) < sizeof(EVENT_HEADER)) {
02702 fpart = (my.pmp + my.size) - (char *) my.pme;
02703 memcpy(my.pmh, my.pme, fpart);
02704 my.pmh = (EVENT_HEADER *) (((char *) my.pmh) + fpart);
02705 leftover = sizeof(EVENT_HEADER) - fpart;
02706 status = midas_physrec_get((void *) my.pmp, &size);
02707 if (status != YB_SUCCESS)
02708 return (YB_DONE);
02709 memset(my.pmp + size, -1, my.size - size);
02710 my.pme = (EVENT_HEADER *) my.pmp;
02711 memcpy(my.pmh, my.pme, leftover);
02712 my.pme = (EVENT_HEADER *) (((char *) my.pme) + leftover);
02713 my.pmh = (EVENT_HEADER *) * pevent;
02714 } else {
02715 memcpy(my.pmh, my.pme, sizeof(EVENT_HEADER));
02716 my.pme = (EVENT_HEADER *) (((char *) my.pme) + sizeof(EVENT_HEADER));
02717 }
02718
02719
02720
02721
02722 my.pmrd = (char *) (my.pmh + 1);
02723
02724
02725 if (my.pmh->event_id == -1)
02726 return YB_DONE;
02727
02728
02729 leftover = my.pmh->data_size;
02730
02731
02732 while (((my.pmp + size) - (char *) my.pme) < leftover) {
02733 fpart = (my.pmp + my.size) - (char *) my.pme;
02734 memcpy(my.pmrd, my.pme, fpart);
02735 my.pmrd += fpart;
02736 leftover -= fpart;
02737 status = midas_physrec_get((void *) my.pmp, &size);
02738 if (status != YB_SUCCESS)
02739 return (YB_DONE);
02740 memset(my.pmp + size, -1, my.size - size);
02741 my.pme = (EVENT_HEADER *) my.pmp;
02742 }
02743
02744
02745 *readn = my.evtlen = my.pmh->data_size + sizeof(EVENT_HEADER);
02746 memcpy(my.pmrd, my.pme, leftover);
02747 my.pme = (EVENT_HEADER *) (((char *) my.pme) + leftover);
02748 my.evtn++;
02749 return YB_SUCCESS;
02750 }
02751
02752
02753 void yb_any_event_display(void *pevent, INT data_fmt, INT dsp_mode, INT dsp_fmt)
02754
02755
02756
02757
02758
02759
02760
02761
02762
02763
02764
02765
02766
02767
02768 {
02769 if (dsp_mode == DSP_RAW)
02770 yb_any_raw_event_display(pevent, data_fmt, dsp_fmt);
02771 else if (dsp_mode == DSP_BANK)
02772 yb_any_bank_event_display(pevent, data_fmt, dsp_fmt);
02773 else
02774 printf("yb_any_event_display- Unknown format:%i\n", dsp_fmt);
02775 return;
02776 }
02777
02778
02779 void yb_any_raw_event_display(void *pevent, INT data_fmt, INT dsp_fmt)
02780
02781
02782
02783
02784
02785
02786
02787
02788
02789
02790
02791
02792 {
02793 DWORD lrl = 0, *pevt = NULL, j, i, total = 0;
02794
02795 if (data_fmt == FORMAT_YBOS) {
02796 lrl = *((DWORD *) (pevent)) + 1;
02797 pevt = (DWORD *) pevent;
02798 } else if (data_fmt == FORMAT_MIDAS) {
02799 lrl = ((((EVENT_HEADER *) pevent)->data_size) + sizeof(EVENT_HEADER)) / sizeof(DWORD);
02800 pevt = (DWORD *) pevent;
02801 }
02802
02803 for (i = 0; i < lrl; i += NLINE) {
02804 printf("%6.0ld->: ", total);
02805 for (j = 0; j < NLINE; j++) {
02806 if ((i + j) < lrl) {
02807 if (dsp_fmt == DSP_DEC)
02808 printf("%8.li ", *pevt);
02809 else
02810 printf("%8.8lx ", *pevt);
02811 pevt++;
02812 }
02813 }
02814 total += NLINE;
02815 printf("\n");
02816 }
02817 }
02818
02819
02820 void yb_any_bank_event_display(void *pevent, INT data_fmt, INT dsp_fmt)
02821
02822
02823
02824
02825
02826
02827
02828
02829
02830
02831
02832
02833
02834
02835 {
02836 char banklist[YB_STRING_BANKLIST_MAX];
02837 YBOS_BANK_HEADER *pybk;
02838 DWORD *pdata;
02839 DWORD bklen, bktyp;
02840 BANK_HEADER *pbh;
02841 BANK *pmbk;
02842 BANK32 *pmbk32;
02843 EVENT_HEADER *pheader;
02844 INT status;
02845
02846 if (data_fmt == FORMAT_YBOS) {
02847
02848
02849
02850 status = ybk_list((DWORD *) pevent, banklist);
02851 printf("#banks:%i - Bank list:-%s-\n", status, banklist);
02852
02853
02854 if ((status =
02855 ybk_find((DWORD *) pevent, "EVID", &bklen, &bktyp,
02856 (void **) &pybk)) == YB_SUCCESS) {
02857 pdata = (DWORD *) ((YBOS_BANK_HEADER *) pybk + 1);
02858 printf
02859 ("--------- EVID --------- Event# %li ------Run#:%li--------\n",
02860 YBOS_EVID_EVENT_NB(pdata), YBOS_EVID_RUN_NUMBER(pdata));
02861 printf
02862 ("Evid:%4.4x- Mask:%4.4x- Serial:%li- Time:0x%lx- Dsize:%li/0x%lx",
02863 (WORD) YBOS_EVID_EVENT_ID(pdata), (WORD) YBOS_EVID_TRIGGER_MASK(pdata)
02864 , YBOS_EVID_SERIAL(pdata), YBOS_EVID_TIME(pdata)
02865 , ((YBOS_BANK_HEADER *) pybk)->length, ((YBOS_BANK_HEADER *) pybk)->length);
02866 }
02867
02868
02869 pybk = NULL;
02870 while ((ybk_iterate((DWORD *) pevent, &pybk, (void **) &pdata) >= 0)
02871 && (pybk != NULL))
02872 ybos_bank_display(pybk, dsp_fmt);
02873 } else if (data_fmt == FORMAT_MIDAS) {
02874
02875 pheader = (EVENT_HEADER *) pevent;
02876 if (pheader->event_id == EVENTID_BOR ||
02877 pheader->event_id == EVENTID_EOR || pheader->event_id == EVENTID_MESSAGE)
02878 return;
02879
02880
02881 printf
02882 ("Evid:%4.4x- Mask:%4.4x- Serial:%li- Time:0x%lx- Dsize:%li/0x%lx",
02883 (WORD) pheader->event_id, (WORD) pheader->trigger_mask,
02884 pheader->serial_number, pheader->time_stamp, pheader->data_size,
02885 pheader->data_size);
02886
02887
02888 pbh = (BANK_HEADER *) (pheader + 1);
02889 if ((pbh->data_size + 8) == pheader->data_size) {
02890
02891 status = bk_list((BANK_HEADER *) (pheader + 1), banklist);
02892 printf("\n#banks:%i - Bank list:-%s-\n", status, banklist);
02893
02894
02895 if (bk_is32(pbh)) {
02896 pmbk32 = NULL;
02897 do {
02898 bk_iterate32(pbh, &pmbk32, &pdata);
02899 if (pmbk32 != NULL)
02900 midas_bank_display32(pmbk32, dsp_fmt);
02901 } while (pmbk32 != NULL);
02902 } else {
02903 pmbk = NULL;
02904 do {
02905 bk_iterate(pbh, &pmbk, &pdata);
02906 if (pmbk != NULL)
02907 midas_bank_display(pmbk, dsp_fmt);
02908 } while (pmbk != NULL);
02909 }
02910 } else {
02911 printf("\nFIXED event with Midas Header\n");
02912 yb_any_raw_event_display(pevent, data_fmt, dsp_fmt);
02913 }
02914 }
02915 return;
02916 }
02917
02918
02919 void yb_any_bank_display(void *pmbh, void *pbk, INT data_fmt, INT dsp_mode, INT dsp_fmt)
02920
02921
02922
02923
02924
02925
02926
02927
02928
02929
02930
02931
02932
02933 {
02934 if (dsp_mode == DSP_RAW)
02935 yb_any_raw_bank_display(pbk, data_fmt, dsp_fmt);
02936 else {
02937 if (data_fmt == FORMAT_MIDAS) {
02938 if (bk_is32(pmbh))
02939 midas_bank_display32((BANK32 *) pbk, dsp_fmt);
02940 else
02941 midas_bank_display((BANK *) pbk, dsp_fmt);
02942 } else if (data_fmt == FORMAT_YBOS)
02943 ybos_bank_display((YBOS_BANK_HEADER *) pbk, dsp_fmt);
02944 }
02945 return;
02946 }
02947
02948
02949 void yb_any_raw_bank_display(void *pbank, INT data_fmt, INT dsp_fmt)
02950
02951
02952
02953
02954
02955
02956
02957
02958
02959
02960
02961
02962 {
02963 DWORD *pdata = NULL, lrl = 0, j, i;
02964
02965 if (data_fmt == FORMAT_YBOS) {
02966 lrl = (((YBOS_BANK_HEADER *) pbank)->length) - 1;
02967 pdata = (DWORD *) (((YBOS_BANK_HEADER *) pbank) + 1);
02968 } else if (data_fmt == FORMAT_MIDAS) {
02969 lrl = ((BANK *) pbank)->data_size >> 2;
02970 pdata = (DWORD *) ((BANK *) (pbank) + 1);
02971 }
02972
02973 for (i = 0; i < lrl; i += NLINE) {
02974 j = 0;
02975 printf("\n%4li-> ", i + j + 1);
02976 for (j = 0; j < NLINE; j++) {
02977 if ((i + j) < lrl) {
02978 if (dsp_fmt == DSP_DEC)
02979 printf("%8.li ", *((DWORD *) pdata));
02980 if (dsp_fmt == DSP_ASC)
02981 printf("%8.8lx ", *((DWORD *) pdata));
02982 if (dsp_fmt == DSP_HEX)
02983 printf("%8.8lx ", *((DWORD *) pdata));
02984 pdata++;
02985 }
02986 }
02987 }
02988 }
02989
02990
02991 void ybos_bank_display(YBOS_BANK_HEADER * pybk, INT dsp_fmt)
02992
02993
02994
02995
02996
02997
02998
02999
03000
03001
03002
03003 {
03004 char bank_name[5], strbktype[32];
03005 DWORD length_type = 0;
03006 DWORD *pdata, *pendbk;
03007 INT i, j;
03008
03009 j = 8;
03010 i = 1;
03011
03012 pdata = (DWORD *) (pybk + 1);
03013 memcpy(&bank_name[0], (char *) &pybk->name, 4);
03014 bank_name[4] = 0;
03015
03016 if (pybk->type == D8_BKTYPE) {
03017 length_type = ((pybk->length - 1) >> 1);
03018 sprintf(strbktype, "double*8 (FMT machine dependent)");
03019 }
03020 if (pybk->type == F4_BKTYPE) {
03021 length_type = pybk->length - 1;
03022 strcpy(strbktype, "Real*4 (FMT machine dependent)");
03023 }
03024 if (pybk->type == I4_BKTYPE) {
03025 length_type = pybk->length - 1;
03026 strcpy(strbktype, "Integer*4");
03027 }
03028 if (pybk->type == I2_BKTYPE) {
03029 length_type = ((pybk->length - 1) << 1);
03030 strcpy(strbktype, "Integer*2");
03031 }
03032 if (pybk->type == I1_BKTYPE) {
03033 length_type = ((pybk->length - 1) << 2);
03034 strcpy(strbktype, "8 bit Bytes");
03035 }
03036 if (pybk->type == A1_BKTYPE) {
03037 length_type = ((pybk->length - 1) << 2);
03038 strcpy(strbktype, "8 bit ASCII");
03039 }
03040 printf("\nBank:%s Length: %li(I*1)/%li(I*4)/%li(Type) Type:%s",
03041 bank_name, ((pybk->length - 1) << 2), pybk->length - 1, length_type, strbktype);
03042 j = 16;
03043
03044 pendbk = pdata + pybk->length - 1;
03045 while ((BYTE *) pdata < (BYTE *) pendbk) {
03046 switch (pybk->type) {
03047 case D8_BKTYPE:
03048 if (j > 7) {
03049 printf("\n%4i-> ", i);
03050 j = 0;
03051 i += 8;
03052 }
03053 printf("%15.5le ", *((double *) pdata));
03054 pdata = (DWORD *) (((double *) pdata) + 1);
03055 j++;
03056 break;
03057 case F4_BKTYPE:
03058 if (j > 7) {
03059 printf("\n%4i-> ", i);
03060 j = 0;
03061 i += 8;
03062 }
03063 if ((dsp_fmt == DSP_DEC) || (dsp_fmt == DSP_UNK))
03064 printf("%8.3e ", *((float *) pdata));
03065 if (dsp_fmt == DSP_HEX)
03066 printf("0x%8.8lx ", *((DWORD *) pdata));
03067 pdata++;
03068 j++;
03069 break;
03070 case I4_BKTYPE:
03071 if (j > 7) {
03072 printf("\n%4i-> ", i);
03073 j = 0;
03074 i += 8;
03075 }
03076 if (dsp_fmt == DSP_DEC)
03077 printf("%8.1li ", *((DWORD *) pdata));
03078 if ((dsp_fmt == DSP_HEX) || (dsp_fmt == DSP_UNK))
03079 printf("0x%8.8lx ", *((DWORD *) pdata));
03080 pdata++;
03081 j++;
03082 break;
03083 case I2_BKTYPE:
03084 if (j > 7) {
03085 printf("\n%4i-> ", i);
03086 j = 0;
03087 i += 8;
03088 }
03089 if (dsp_fmt == DSP_DEC)
03090 printf("%5.1i ", *((WORD *) pdata));
03091 if ((dsp_fmt == DSP_HEX) || (dsp_fmt == DSP_UNK))
03092 printf("0x%4.4x ", *((WORD *) pdata));
03093 pdata = (DWORD *) (((WORD *) pdata) + 1);
03094 j++;
03095 break;
03096 case A1_BKTYPE:
03097 if (j > 15) {
03098 printf("\n%4i-> ", i);
03099 j = 0;
03100 i += 16;
03101 }
03102 if ((dsp_fmt == DSP_ASC) || (dsp_fmt == DSP_UNK))
03103 printf("%1.1s ", (char *) pdata);
03104 if (dsp_fmt == DSP_DEC)
03105 printf("%2.i ", *((BYTE *) pdata));
03106 if (dsp_fmt == DSP_HEX)
03107 printf("0x%2.2x ", *((BYTE *) pdata));
03108 pdata = (DWORD *) (((BYTE *) pdata) + 1);
03109 j++;
03110 break;
03111 case I1_BKTYPE:
03112 if (j > 7) {
03113 printf("\n%4i-> ", i);
03114 j = 0;
03115 i += 8;
03116 }
03117 if ((dsp_fmt == DSP_DEC) || (dsp_fmt == DSP_UNK))
03118 printf("%4.i ", *((BYTE *) pdata));
03119 if (dsp_fmt == DSP_HEX)
03120 printf("0x%2.2x ", *((BYTE *) pdata));
03121 pdata = (DWORD *) (((BYTE *) pdata) + 1);
03122 j++;
03123 break;
03124 default:
03125 printf("ybos_bak_display-E- Unknown bank type %li\n", pybk->type);
03126 break;
03127
03128 }
03129 }
03130 printf("\n");
03131 return;
03132 }
03133
03134
03135 void midas_bank_display(BANK * pbk, INT dsp_fmt)
03136
03137
03138
03139
03140
03141
03142
03143
03144
03145
03146
03147 {
03148 char bank_name[5], strbktype[32];
03149 char *pdata, *pendbk;
03150 DWORD length_type = 0, lrl;
03151 INT type, i, j;
03152
03153 lrl = pbk->data_size;
03154 type = pbk->type & 0xff;
03155 bank_name[4] = 0;
03156 memcpy(bank_name, (char *) (pbk->name), 4);
03157 pdata = (char *) (pbk + 1);
03158
03159 j = 64;
03160 i = 1;
03161 strcpy(strbktype, "Unknown format");
03162 if (type == TID_DOUBLE) {
03163 length_type = sizeof(double);
03164 strcpy(strbktype, "double*8");
03165 }
03166 if (type == TID_FLOAT) {
03167 length_type = sizeof(float);
03168 strcpy(strbktype, "Real*4 (FMT machine dependent)");
03169 }
03170 if (type == TID_DWORD) {
03171 length_type = sizeof(DWORD);
03172 strcpy(strbktype, "Unsigned Integer*4");
03173 }
03174 if (type == TID_INT) {
03175 length_type = sizeof(INT);
03176 strcpy(strbktype, "Signed Integer*4");
03177 }
03178 if (type == TID_WORD) {
03179 length_type = sizeof(WORD);
03180 strcpy(strbktype, "Unsigned Integer*2");
03181 }
03182 if (type == TID_SHORT) {
03183 length_type = sizeof(short);
03184 strcpy(strbktype, "Signed Integer*2");
03185 }
03186 if (type == TID_BYTE) {
03187 length_type = sizeof(BYTE);
03188 strcpy(strbktype, "Unsigned Bytes");
03189 }
03190 if (type == TID_SBYTE) {
03191 length_type = sizeof(BYTE);
03192 strcpy(strbktype, "Signed Bytes");
03193 }
03194 if (type == TID_BOOL) {
03195 length_type = sizeof(DWORD);
03196 strcpy(strbktype, "Boolean");
03197 }
03198 if (type == TID_CHAR) {
03199 length_type = sizeof(char);
03200 strcpy(strbktype, "8 bit ASCII");
03201 }
03202 if (type == TID_STRUCT) {
03203 length_type = sizeof(char);
03204 strcpy(strbktype, "STRUCT (not supported->8 bits)");
03205 }
03206 if (type == TID_STRING) {
03207 length_type = sizeof(char);
03208 strcpy(strbktype, "String 8bit ASCI");
03209 }
03210
03211 printf("\nBank:%s Length: %li(I*1)/%li(I*4)/%li(Type) Type:%s",
03212 bank_name, lrl, lrl >> 2, lrl / length_type, strbktype);
03213
03214 pendbk = pdata + lrl;
03215 while (pdata < pendbk) {
03216 switch (type) {
03217 case TID_DOUBLE:
03218 if (j > 3) {
03219 printf("\n%4i-> ", i);
03220 j = 0;
03221 i += 4;
03222 }
03223 printf("%15.5le ", *((double *) pdata));
03224 pdata = (char *) (((double *) pdata) + 1);
03225 j++;
03226 break;
03227 case TID_FLOAT:
03228 if (j > 7) {
03229 printf("\n%4i-> ", i);
03230 j = 0;
03231 i += 8;
03232 }
03233 if ((dsp_fmt == DSP_DEC) || (dsp_fmt == DSP_UNK))
03234 printf("%8.3e ", *((float *) pdata));
03235 if (dsp_fmt == DSP_HEX)
03236 printf("0x%8.8lx ", *((DWORD *) pdata));
03237 pdata = (char *) (((DWORD *) pdata) + 1);
03238 j++;
03239 break;
03240 case TID_DWORD:
03241 if (j > 7) {
03242 printf("\n%4i-> ", i);
03243 j = 0;
03244 i += 8;
03245 }
03246 if (dsp_fmt == DSP_DEC)
03247 printf("%8.1li ", *((DWORD *) pdata));
03248 if ((dsp_fmt == DSP_HEX) || (dsp_fmt == DSP_UNK))
03249 printf("0x%8.8lx ", *((DWORD *) pdata));
03250 pdata = (char *) (((DWORD *) pdata) + 1);
03251 j++;
03252 break;
03253 case TID_INT:
03254 if (j > 7) {
03255 printf("\n%4i-> ", i);
03256 j = 0;
03257 i += 8;
03258 }
03259 if ((dsp_fmt == DSP_DEC) || (dsp_fmt == DSP_UNK))
03260 printf("%8.1li ", *((DWORD *) pdata));
03261 if (dsp_fmt == DSP_HEX)
03262 printf("0x%8.8lx ", *((DWORD *) pdata));
03263 pdata = (char *) (((DWORD *) pdata) + 1);
03264 j++;
03265 break;
03266 case TID_WORD:
03267 if (j > 7) {
03268 printf("\n%4i-> ", i);
03269 j = 0;
03270 i += 8;
03271 }
03272 if (dsp_fmt == DSP_DEC)
03273 printf("%5.1i ", *((WORD *) pdata));
03274 if ((dsp_fmt == DSP_HEX) || (dsp_fmt == DSP_UNK))
03275 printf("0x%4.4x ", *((WORD *) pdata));
03276 pdata = (char *) (((WORD *) pdata) + 1);
03277 j++;
03278 break;
03279 case TID_SHORT:
03280 if (j > 7) {
03281 printf("\n%4i-> ", i);
03282 j = 0;
03283 i += 8;
03284 }
03285 if ((dsp_fmt == DSP_DEC) || (dsp_fmt == DSP_UNK))
03286 printf("%5.1i ", *((short *) pdata));
03287 if (dsp_fmt == DSP_HEX)
03288 printf("0x%4.4x ", *((short *) pdata));
03289 pdata = (char *) (((short *) pdata) + 1);
03290 j++;
03291 break;
03292 case TID_BYTE:
03293 case TID_STRUCT:
03294 if (j > 15) {
03295 printf("\n%4i-> ", i);
03296 j = 0;
03297 i += 16;
03298 }
03299 if (dsp_fmt == DSP_DEC)
03300 printf("%4.i ", *((BYTE *) pdata));
03301 if ((dsp_fmt == DSP_HEX) || (dsp_fmt == DSP_UNK))
03302 printf("0x%2.2x ", *((BYTE *) pdata));
03303 pdata++;
03304 j++;
03305 break;
03306 case TID_SBYTE:
03307 if (j > 15) {
03308 printf("\n%4i-> ", i);
03309 j = 0;
03310 i += 16;
03311 }
03312 if ((dsp_fmt == DSP_DEC) || (dsp_fmt == DSP_UNK))
03313 printf("%4.i ", *((BYTE *) pdata));
03314 if (dsp_fmt == DSP_HEX)
03315 printf("0x%2.2x ", *((BYTE *) pdata));
03316 pdata++;
03317 j++;
03318 break;
03319 case TID_BOOL:
03320 if (j > 15) {
03321 printf("\n%4i-> ", i);
03322 j = 0;
03323 i += 16;
03324 }
03325 (*((BOOL *) pdata) != 0) ? printf("Y ") : printf("N ");
03326 pdata = (char *) (((DWORD *) pdata) + 1);
03327 j++;
03328 break;
03329 case TID_CHAR:
03330 case TID_STRING:
03331 if (j > 15) {
03332 printf("\n%4i-> ", i);
03333 j = 0;
03334 i += 16;
03335 }
03336 if (dsp_fmt == DSP_DEC)
03337 printf("%3.i ", *((BYTE *) pdata));
03338 if ((dsp_fmt == DSP_ASC) || (dsp_fmt == DSP_UNK))
03339 printf("%1.1s ", (char *) pdata);
03340 if (dsp_fmt == DSP_HEX)
03341 printf("0x%2.2x ", *((BYTE *) pdata));
03342 pdata++;
03343 j++;
03344 break;
03345 default:
03346 printf("bank type not supported (%d)\n", type);
03347 return;
03348 break;
03349 }
03350 }
03351 printf("\n");
03352 return;
03353 }
03354
03355
03356 void midas_bank_display32(BANK32 * pbk, INT dsp_fmt)
03357
03358
03359
03360
03361
03362
03363
03364
03365
03366
03367
03368
03369 {
03370 char bank_name[5], strbktype[32];
03371 char *pdata, *pendbk;
03372 DWORD length_type = 0, lrl;
03373 INT type, i, j;
03374
03375 lrl = pbk->data_size;
03376 type = pbk->type & 0xff;
03377 bank_name[4] = 0;
03378 memcpy(bank_name, (char *) (pbk->name), 4);
03379 pdata = (char *) (pbk + 1);
03380
03381 j = 64;
03382 i = 1;
03383 strcpy(strbktype, "Unknown format");
03384 if (type == TID_DOUBLE) {
03385 length_type = sizeof(double);
03386 strcpy(strbktype, "double*8");
03387 }
03388 if (type == TID_FLOAT) {
03389 length_type = sizeof(float);
03390 strcpy(strbktype, "Real*4 (FMT machine dependent)");
03391 }
03392 if (type == TID_DWORD) {
03393 length_type = sizeof(DWORD);
03394 strcpy(strbktype, "Unsigned Integer*4");
03395 }
03396 if (type == TID_INT) {
03397 length_type = sizeof(INT);
03398 strcpy(strbktype, "Signed Integer*4");
03399 }
03400 if (type == TID_WORD) {
03401 length_type = sizeof(WORD);
03402 strcpy(strbktype, "Unsigned Integer*2");
03403 }
03404 if (type == TID_SHORT) {
03405 length_type = sizeof(short);
03406 strcpy(strbktype, "Signed Integer*2");
03407 }
03408 if (type == TID_BYTE) {
03409 length_type = sizeof(BYTE);
03410 strcpy(strbktype, "Unsigned Bytes");
03411 }
03412 if (type == TID_SBYTE) {
03413 length_type = sizeof(BYTE);
03414 strcpy(strbktype, "Signed Bytes");
03415 }
03416 if (type == TID_BOOL) {
03417 length_type = sizeof(DWORD);
03418 strcpy(strbktype, "Boolean");
03419 }
03420 if (type == TID_CHAR) {
03421 length_type = sizeof(char);
03422 strcpy(strbktype, "8 bit ASCII");
03423 }
03424 if (type == TID_STRUCT) {
03425 length_type = sizeof(char);
03426 strcpy(strbktype, "STRUCT (not supported->8 bits)");
03427 }
03428 if (type == TID_STRING) {
03429 length_type = sizeof(char);
03430 strcpy(strbktype, "String 8bit ASCI");
03431 }
03432
03433 printf("\nBank:%s Length: %li(I*1)/%li(I*4)/%li(Type) Type:%s",
03434 bank_name, lrl, lrl >> 2, lrl / length_type, strbktype);
03435
03436 pendbk = pdata + lrl;
03437 while (pdata < pendbk) {
03438 switch (type) {
03439 case TID_DOUBLE:
03440 if (j > 3) {
03441 printf("\n%4i-> ", i);
03442 j = 0;
03443 i += 4;
03444 }
03445 printf("%15.5le ", *((double *) pdata));
03446 pdata = (char *) (((double *) pdata) + 1);
03447 j++;
03448 break;
03449 case TID_FLOAT:
03450 if (j > 7) {
03451 printf("\n%4i-> ", i);
03452 j = 0;
03453 i += 8;
03454 }
03455 if ((dsp_fmt == DSP_DEC) || (dsp_fmt == DSP_UNK))
03456 printf("%8.3e ", *((float *) pdata));
03457 if (dsp_fmt == DSP_HEX)
03458 printf("0x%8.8lx ", *((DWORD *) pdata));
03459 pdata = (char *) (((DWORD *) pdata) + 1);
03460 j++;
03461 break;
03462 case TID_DWORD:
03463 if (j > 7) {
03464 printf("\n%4i-> ", i);
03465 j = 0;
03466 i += 8;
03467 }
03468 if (dsp_fmt == DSP_DEC)
03469 printf("%8.1li ", *((DWORD *) pdata));
03470 if ((dsp_fmt == DSP_HEX) || (dsp_fmt == DSP_UNK))
03471 printf("0x%8.8lx ", *((DWORD *) pdata));
03472 pdata = (char *) (((DWORD *) pdata) + 1);
03473 j++;
03474 break;
03475 case TID_INT:
03476 if (j > 7) {
03477 printf("\n%4i-> ", i);
03478 j = 0;
03479 i += 8;
03480 }
03481 if ((dsp_fmt == DSP_DEC) || (dsp_fmt == DSP_UNK))
03482 printf("%8.1li ", *((DWORD *) pdata));
03483 if (dsp_fmt == DSP_HEX)
03484 printf("0x%8.8lx ", *((DWORD *) pdata));
03485 pdata = (char *) (((DWORD *) pdata) + 1);
03486 j++;
03487 break;
03488 case TID_WORD:
03489 if (j > 7) {
03490 printf("\n%4i-> ", i);
03491 j = 0;
03492 i += 8;
03493 }
03494 if (dsp_fmt == DSP_DEC)
03495 printf("%5.1i ", *((WORD *) pdata));
03496 if ((dsp_fmt == DSP_HEX) || (dsp_fmt == DSP_UNK))
03497 printf("0x%4.4x ", *((WORD *) pdata));
03498 pdata = (char *) (((WORD *) pdata) + 1);
03499 j++;
03500 break;
03501 case TID_SHORT:
03502 if (j > 7) {
03503 printf("\n%4i-> ", i);
03504 j = 0;
03505 i += 8;
03506 }
03507 if ((dsp_fmt == DSP_DEC) || (dsp_fmt == DSP_UNK))
03508 printf("%5.1i ", *((short *) pdata));
03509 if (dsp_fmt == DSP_HEX)
03510 printf("0x%4.4x ", *((short *) pdata));
03511 pdata = (char *) (((short *) pdata) + 1);
03512 j++;
03513 break;
03514 case TID_BYTE:
03515 case TID_STRUCT:
03516 if (j > 15) {
03517 printf("\n%4i-> ", i);
03518 j = 0;
03519 i += 16;
03520 }
03521 if (dsp_fmt == DSP_DEC)
03522 printf("%4.i ", *((BYTE *) pdata));
03523 if ((dsp_fmt == DSP_HEX) || (dsp_fmt == DSP_UNK))
03524 printf("0x%2.2x ", *((BYTE *) pdata));
03525 pdata++;
03526 j++;
03527 break;
03528 case TID_SBYTE:
03529 if (j > 15) {
03530 printf("\n%4i-> ", i);
03531 j = 0;
03532 i += 16;
03533 }
03534 if ((dsp_fmt == DSP_DEC) || (dsp_fmt == DSP_UNK))
03535 printf("%4.i ", *((BYTE *) pdata));
03536 if (dsp_fmt == DSP_HEX)
03537 printf("0x%2.2x ", *((BYTE *) pdata));
03538 pdata++;
03539 j++;
03540 break;
03541 case TID_BOOL:
03542 if (j > 15) {
03543 printf("\n%4i-> ", i);
03544 j = 0;
03545 i += 16;
03546 }
03547 (*((BOOL *) pdata) != 0) ? printf("Y ") : printf("N ");
03548 pdata = (char *) (((DWORD *) pdata) + 1);
03549 j++;
03550 break;
03551 case TID_CHAR:
03552 case TID_STRING:
03553 if (j > 15) {
03554 printf("\n%4i-> ", i);
03555 j = 0;
03556 i += 16;
03557 }
03558 if (dsp_fmt == DSP_DEC)
03559 printf("%3.i ", *((BYTE *) pdata));
03560 if (dsp_fmt == DSP_ASC || (dsp_fmt == DSP_UNK))
03561 printf("%1.1s ", (char *) pdata);
03562 if (dsp_fmt == DSP_HEX)
03563 printf("0x%2.2x ", *((BYTE *) pdata));
03564 pdata++;
03565 j++;
03566 break;
03567 default:
03568 printf("bank type not supported (%d)\n", type);
03569 return;
03570 break;
03571 }
03572 }
03573 printf("\n");
03574 return;
03575 }
03576
03577
03578
03579
03580
03581
03582 INT yb_file_recompose(void *pevt, INT format, char *svpath, INT file_mode)
03583
03584
03585
03586
03587
03588
03589
03590
03591
03592
03593
03594
03595
03596
03597
03598
03599
03600 {
03601 YM_CFILE *pmyfch;
03602 int slot, status;
03603
03604 if (file_mode == YB_NO_RECOVER)
03605 return YB_SUCCESS;
03606
03607 if (format == FORMAT_YBOS) {
03608 if ((status = ybk_locate((DWORD *) pevt, "CFIL", &pmyfch)) <= 0)
03609 return (status);
03610 } else if (format == FORMAT_MIDAS) {
03611 if ((((EVENT_HEADER *) pevt)->event_id == EVENTID_BOR) ||
03612 (((EVENT_HEADER *) pevt)->event_id == EVENTID_EOR) ||
03613 (((EVENT_HEADER *) pevt)->event_id == EVENTID_MESSAGE))
03614 return YB_BANK_NOT_FOUND;
03615
03616 pevt = (EVENT_HEADER *) pevt + 1;
03617 if ((status = bk_locate(pevt, "CFIL", &pmyfch)) <= 0)
03618 return (status);
03619 }
03620
03621 printf("%i - %i - %i - %i - %i -%i -%i \n", pmyfch->file_ID,
03622 pmyfch->size, pmyfch->fragment_size, pmyfch->total_fragment,
03623 pmyfch->current_fragment, pmyfch->current_read_byte, pmyfch->run_number);
03624
03625
03626 for (slot = 0; slot < MAX_YM_FILE; slot++) {
03627 if ((ymfile[slot].fHandle != 0)
03628 && (pmyfch->file_ID == ymfile[slot].file_ID)) {
03629
03630 if ((status = yb_ymfile_update(slot, format, pevt)) != YB_SUCCESS) {
03631 printf("yb_ymfile_update() failed\n");
03632 return status;
03633 }
03634 goto check;
03635 }
03636
03637 }
03638
03639
03640 if ((status = yb_ymfile_open(&slot, format, pevt, svpath, file_mode)) != YB_SUCCESS) {
03641 printf("yb_ymfile_open() failed\n");
03642 return status;
03643 }
03644
03645 if ((status = yb_ymfile_update(slot, format, pevt)) != YB_SUCCESS) {
03646 printf("yb_ymfile_update() failed\n");
03647 return status;
03648 }
03649
03650 check:
03651
03652 for (slot = 0; slot < MAX_YM_FILE; slot++) {
03653 if (ymfile[slot].fHandle != 0) {
03654
03655 return YB_INCOMPLETE;
03656 }
03657
03658 }
03659 return YB_COMPLETE;
03660 }
03661
03662
03663 INT yb_ymfile_open(int *slot, int fmt, void *pevt, char *svpath, INT file_mode)
03664
03665
03666
03667
03668
03669
03670
03671
03672
03673
03674
03675
03676
03677
03678
03679 {
03680 YM_CFILE *pmyfch;
03681 YM_PFILE *pmyfph;
03682 char *pfilename;
03683 char srun[16], sslot[3];
03684 int i, status;
03685
03686
03687 *slot = -1;
03688
03689 if (fmt == FORMAT_YBOS) {
03690 if ((status = ybk_locate((DWORD *) pevt, "CFIL", &pmyfch)) <= 0)
03691 return (status);
03692 if ((status = ybk_locate((DWORD *) pevt, "PFIL", &pmyfph)) <= 0)
03693 return (status);
03694 } else if (fmt == FORMAT_MIDAS) {
03695 if ((status = bk_locate(pevt, "CFIL", &pmyfch)) <= 0)
03696 return (status);
03697 if ((status = bk_locate(pevt, "PFIL", &pmyfph)) <= 0)
03698 return (status);
03699 } else
03700 return -2;
03701
03702 for (i = 0; i < MAX_YM_FILE; i++)
03703 if (ymfile[i].fHandle == 0)
03704 break;
03705 if (i < MAX_YM_FILE) {
03706
03707 ymfile[i].file_ID = pmyfch->file_ID;
03708 strcpy(ymfile[i].path, pmyfph->path);
03709
03710
03711 pfilename = pmyfph->path;
03712 if (strrchr(pmyfph->path, '/') > pfilename)
03713 pfilename = strrchr(pmyfph->path, '/');
03714 if (strrchr(pmyfph->path, '\\') > pfilename)
03715 pfilename = strrchr(pmyfph->path, '\\');
03716 if (strrchr(pmyfph->path, ':') > pfilename)
03717 pfilename = strrchr(pmyfph->path, ':');
03718 if (*pfilename != pmyfph->path[0])
03719 pfilename++;
03720
03721
03722 if (svpath[0] != 0) {
03723 ymfile[i].path[0] = 0;
03724 strncat(ymfile[i].path, svpath, strlen(svpath));
03725 if (ymfile[i].path[strlen(ymfile[i].path) - 1] != DIR_SEPARATOR)
03726 strcat(ymfile[i].path, DIR_SEPARATOR_STR);
03727
03728 strcat(ymfile[i].path, pfilename);
03729 }
03730 if (file_mode == YB_ADD_RUN) {
03731 strcat(ymfile[i].path, ".");
03732 sprintf(srun, "Run%4.4i", pmyfch->run_number);
03733 strncat(ymfile[i].path, srun, strlen(srun));
03734 }
03735
03736
03737 if (i > 0) {
03738 sprintf(sslot, ".%03i", i);
03739 strcat(ymfile[i].path, sslot);
03740 }
03741
03742
03743 if ((ymfile[i].fHandle =
03744 open(ymfile[i].path, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_LARGEFILE, 0644)) == -1) {
03745 ymfile[i].fHandle = 0;
03746 printf("File %s cannot be created\n", ymfile[i].path);
03747 return (SS_FILE_ERROR);
03748 }
03749 } else {
03750
03751 printf("No more slot for file %s\n", pmyfph->path);
03752 return YB_NOMORE_SLOT;
03753 }
03754
03755 ymfile[i].current_read_byte = 0;
03756 ymfile[i].current_fragment = 0;
03757 *slot = i;
03758 return YB_SUCCESS;
03759 }
03760
03761
03762 INT yb_ymfile_update(int slot, int fmt, void *pevt)
03763
03764
03765
03766
03767
03768
03769
03770
03771
03772
03773
03774 {
03775 YM_CFILE *pmyfch;
03776 char *pmyfd;
03777 int status;
03778 int nwrite;
03779
03780 if (fmt == FORMAT_YBOS) {
03781 if ((status = ybk_locate((DWORD *) pevt, "CFIL", &pmyfch)) <= 0)
03782 return (status);
03783 if ((status = ybk_locate((DWORD *) pevt, "DFIL", &pmyfd)) <= 0)
03784 return (status);
03785
03786
03787 if (ymfile[slot].current_fragment + 1 != pmyfch->current_fragment) {
03788 printf("Out of sequence %i / %i\n", ymfile[slot].current_fragment,
03789 pmyfch->current_fragment);
03790 }
03791
03792 nwrite = write(ymfile[slot].fHandle, pmyfd, pmyfch->fragment_size);
03793
03794
03795 ymfile[slot].current_read_byte += nwrite;
03796 ymfile[slot].current_fragment++;
03797
03798 if (ymfile[slot].current_fragment == pmyfch->total_fragment) {
03799
03800 close(ymfile[slot].fHandle);
03801 printf("File %s (%i) completed\n", ymfile[slot].path,
03802 ymfile[slot].current_read_byte);
03803
03804 ymfile[slot].fHandle = 0;
03805 return YB_SUCCESS;
03806 }
03807 else {
03808
03809 return YB_SUCCESS;
03810 }
03811 } else if (fmt == FORMAT_MIDAS) {
03812 if ((status = bk_locate(pevt, "CFIL", &pmyfch)) <= 0)
03813 return (status);
03814 if ((status = bk_locate(pevt, "DFIL", &pmyfd)) <= 0)
03815 return (status);
03816
03817
03818 if (ymfile[slot].current_fragment + 1 != pmyfch->current_fragment) {
03819 printf("Out of sequence %i / %i\n", ymfile[slot].current_fragment,
03820 pmyfch->current_fragment);
03821 }
03822
03823 nwrite = write(ymfile[slot].fHandle, pmyfd, pmyfch->fragment_size);
03824
03825
03826 ymfile[slot].current_read_byte += nwrite;
03827 ymfile[slot].current_fragment++;
03828
03829 if (ymfile[slot].current_fragment == pmyfch->total_fragment) {
03830
03831 close(ymfile[slot].fHandle);
03832 printf("File %s (%i) completed\n", ymfile[slot].path,
03833 ymfile[slot].current_read_byte);
03834
03835 ymfile[slot].fHandle = 0;
03836 return YB_SUCCESS;
03837 }
03838 else {
03839
03840 return YB_SUCCESS;
03841 }
03842 } else
03843 return YB_UNKNOWN_FORMAT;
03844 }
03845 #endif
03846
03847
03848
03849
03850
03851
03852
03853
03854
03855
03856
03857 #endif
03858
03859
03860
03861
03862
03863