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