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