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 #ifndef DOXYGEN_SHOULD_SKIP_THIS
00027
00028
00029
00030
00031
00032 #define TRACE
00033 #include "midas.h"
00034 #include "msystem.h"
00035
00036 #ifdef HAVE_FTPLIB
00037 #include "ftplib.h"
00038 FTP_CON *ftp_con;
00039 #endif
00040
00041 #ifdef HAVE_ZLIB
00042 #include "zlib.h"
00043 #endif
00044
00045 #include "mdsupport.h"
00046
00047 INT md_dev_os_read(INT handle, INT type, void *prec, DWORD nbytes, DWORD * nread);
00048 INT md_dev_os_write(INT handle, INT type, void *prec, DWORD nbytes, DWORD * written);
00049 void md_bank_event_display(void *pevent, INT data_fmt, INT dsp_fmt, INT dsp_mode, char *bn);
00050 void md_raw_event_display(void *pevent, INT data_fmt, INT dsp_fmt);
00051 void md_raw_bank_display(void *pbank, INT data_fmt, INT dsp_fmt);
00052
00053 INT midas_event_get(void **pevent, DWORD * size);
00054 INT midas_physrec_get(void *prec, DWORD * readn);
00055 INT midas_event_skip(INT evtn);
00056 void midas_bank_display(BANK * pbk, INT dsp_fmt);
00057 void midas_bank_display32(BANK32 * pbk, INT dsp_fmt);
00058
00059 struct stat *filestat;
00060 char *ptopmrd;
00061
00062 #ifdef HAVE_ZLIB
00063 gzFile filegz;
00064 #endif
00065
00066
00067 typedef struct {
00068 INT handle;
00069 char name[128];
00070
00071 char *pmp;
00072 EVENT_HEADER *pmh;
00073 EVENT_HEADER *pme;
00074 char *pmrd;
00075
00076 DWORD evtn;
00077 DWORD serial;
00078 DWORD evtlen;
00079 DWORD size;
00080 DWORD recn;
00081 INT fmt;
00082 INT type;
00083 DWORD runn;
00084 BOOL zipfile;
00085 } MY;
00086
00087 MY my;
00088
00089 #endif
00090
00091
00092 INT mftp_open(char *destination, FTP_CON ** con)
00093 {
00094 INT status;
00095 short port = 0;
00096 char *token, host_name[HOST_NAME_LENGTH],
00097 user[256], pass[256], directory[256], file_name[256], file_mode[256];
00098
00099
00100
00101
00102
00103
00104
00105 token = strtok(destination, ",");
00106 if (token)
00107 strcpy(host_name, token);
00108
00109 token = strtok(NULL, ",");
00110 if (token)
00111 port = atoi(token);
00112
00113 token = strtok(NULL, ",");
00114 if (token)
00115 strcpy(user, token);
00116
00117 token = strtok(NULL, ",");
00118 if (token)
00119 strcpy(pass, token);
00120
00121 token = strtok(NULL, ",");
00122 if (token)
00123 strcpy(directory, token);
00124
00125 token = strtok(NULL, ",");
00126 if (token)
00127 strcpy(file_name, token);
00128
00129 token = strtok(NULL, ",");
00130 file_mode[0] = 0;
00131 if (token)
00132 strcpy(file_mode, token);
00133
00134 status = ftp_login(con, host_name, port, user, pass, "");
00135 if (status >= 0)
00136 return status;
00137
00138 status = ftp_chdir(*con, directory);
00139 if (status >= 0) {
00140
00141 ftp_mkdir(*con, directory);
00142 status = ftp_chdir(*con, directory);
00143 }
00144 if (status >= 0)
00145 return status;
00146 status = ftp_binary(*con);
00147 if (status >= 0)
00148 return status;
00149
00150 if (file_mode[0]) {
00151 status = ftp_command(*con, "umask %s", file_mode, 200, 250, EOF);
00152 if (status >= 0)
00153 return status;
00154 }
00155
00156 while (token) {
00157 token = strtok(NULL, ",");
00158 if (token) {
00159 status = ftp_command(*con, token, NULL, 200, 250, EOF);
00160 if (status >= 0)
00161 return status;
00162 }
00163 }
00164
00165 if (ftp_open_write(*con, file_name) >= 0)
00166 return (*con)->err_no;
00167
00168 return SS_SUCCESS;
00169 }
00170
00171
00172 INT md_file_ropen(char *infile, INT data_fmt)
00173
00174
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185 {
00186 INT status;
00187
00188
00189 strcpy(my.name, infile);
00190
00191
00192 my.zipfile = FALSE;
00193 if ((strncmp(my.name, "/dev", 4) == 0) || (strncmp(my.name, "\\\\.\\", 4) == 0)) {
00194
00195 my.type = LOG_TYPE_TAPE;
00196 } else {
00197
00198 my.type = LOG_TYPE_DISK;
00199 if (strncmp(infile + strlen(infile) - 3, ".gz", 3) == 0)
00200 my.zipfile = TRUE;
00201 }
00202
00203
00204 if (!my.zipfile) {
00205 if (my.type == LOG_TYPE_TAPE) {
00206 status = ss_tape_open(my.name, O_RDONLY | O_BINARY, &my.handle);
00207 } else if ((my.handle = open(my.name, O_RDONLY | O_BINARY | O_LARGEFILE, 0644)) == -1) {
00208 printf("dev name :%s Handle:%d \n", my.name, my.handle);
00209 return (SS_FILE_ERROR);
00210 }
00211 } else {
00212 #ifdef HAVE_ZLIB
00213 if (my.type == LOG_TYPE_TAPE) {
00214 printf(" Zip on tape not yet supported \n");
00215 return (SS_FILE_ERROR);
00216 }
00217 filegz = gzopen(my.name, "rb");
00218 my.handle = 0;
00219 if (filegz == NULL) {
00220 printf("dev name :%s gzopen error:%d \n", my.name, my.handle);
00221 return (SS_FILE_ERROR);
00222 }
00223 #else
00224 cm_msg(MERROR, "mdsupport", "Zlib not included ... gz file not supported");
00225 return (SS_FILE_ERROR);
00226 #endif
00227 }
00228
00229 if (data_fmt == FORMAT_YBOS) {
00230 assert(!"YBOS support not supported anymore");
00231 } else if (data_fmt == FORMAT_MIDAS) {
00232 my.fmt = FORMAT_MIDAS;
00233 my.size = TAPE_BUFFER_SIZE;
00234 my.pmp = (char *) malloc(my.size);
00235 if (my.pmp == NULL)
00236 return SS_NO_MEMORY;
00237 my.pme = (EVENT_HEADER *) my.pmp;
00238
00239
00240 if (my.pmrd != NULL)
00241 free(my.pmrd);
00242 my.pmrd = (char *) malloc(5 * MAX_EVENT_SIZE);
00243 ptopmrd = my.pmrd;
00244 if (my.pmrd == NULL)
00245 return SS_NO_MEMORY;
00246 memset((char *) my.pmrd, -1, 5 * MAX_EVENT_SIZE);
00247 my.pmh = (EVENT_HEADER *) my.pmrd;
00248 }
00249
00250
00251 my.recn = -1;
00252 my.evtn = 0;
00253 return (MD_SUCCESS);
00254 }
00255
00256
00257 INT md_file_rclose(INT data_fmt)
00258
00259
00260
00261
00262
00263
00264
00265
00266
00267
00268 {
00269 int i;
00270
00271 i = data_fmt;
00272
00273 switch (my.type) {
00274 case LOG_TYPE_TAPE:
00275 case LOG_TYPE_DISK:
00276
00277 if (my.zipfile) {
00278 #ifdef HAVE_ZLIB
00279 gzclose(filegz);
00280 #endif
00281 } else {
00282 if (my.handle != 0)
00283 close(my.handle);
00284 }
00285 break;
00286 }
00287 if (ptopmrd != NULL)
00288 free(ptopmrd);
00289 if (my.pmp != NULL)
00290 free(my.pmp);
00291 my.pmp = NULL;
00292 my.pmh = NULL;
00293 ptopmrd = NULL;
00294 my.pmrd = NULL;
00295 return (MD_SUCCESS);
00296 }
00297
00298
00299 INT md_file_wopen(INT type, INT data_fmt, char *filename, INT * hDev)
00300
00301
00302
00303
00304
00305
00306
00307
00308
00309
00310
00311
00312 {
00313 INT status = 0;
00314
00315 if (type == LOG_TYPE_DISK)
00316
00317 {
00318 if (data_fmt == FORMAT_YBOS) {
00319 assert(!"YBOS not supported anymore");
00320 } else if (data_fmt == FORMAT_MIDAS) {
00321 #ifdef OS_WINNT
00322 *hDev =
00323 (int) CreateFile(filename, GENERIC_WRITE, FILE_SHARE_READ,
00324 NULL, CREATE_ALWAYS,
00325 FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH | FILE_FLAG_SEQUENTIAL_SCAN, 0);
00326 #else
00327 *hDev = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_LARGEFILE, 0644);
00328 #endif
00329 status = *hDev < 0 ? SS_FILE_ERROR : SS_SUCCESS;
00330 }
00331 } else if (type == LOG_TYPE_TAPE) {
00332 if (data_fmt == FORMAT_YBOS) {
00333 assert(!"YBOS not supported anymore");
00334 } else if (data_fmt == FORMAT_MIDAS)
00335 status = ss_tape_open(filename, O_WRONLY | O_CREAT | O_TRUNC, hDev);
00336 } else if (type == LOG_TYPE_FTP) {
00337 #ifdef HAVE_FTPLIB
00338 status = mftp_open(filename, (FTP_CON **) & ftp_con);
00339 if (status != SS_SUCCESS) {
00340 *hDev = 0;
00341 return status;
00342 } else
00343 *hDev = 1;
00344 #else
00345 cm_msg(MERROR, "mdsupport", "FTP support not included");
00346 return SS_FILE_ERROR;
00347 #endif
00348 }
00349
00350 return status;
00351 }
00352
00353
00354 INT md_file_wclose(INT handle, INT type, INT data_fmt, char *destination)
00355
00356
00357
00358
00359
00360
00361
00362
00363
00364
00365 {
00366 INT status;
00367
00368 status = SS_SUCCESS;
00369 switch (type) {
00370 case LOG_TYPE_TAPE:
00371
00372 status = ss_tape_write_eof(handle);
00373 ss_tape_close(handle);
00374 break;
00375 case LOG_TYPE_DISK:
00376
00377 if (handle != 0)
00378 #ifdef OS_WINNT
00379 CloseHandle((HANDLE) handle);
00380 #else
00381 close(handle);
00382 #endif
00383 break;
00384 case LOG_TYPE_FTP:
00385 #ifdef HAVE_FTPLIB
00386 {
00387 char *p, filename[256];
00388 int i;
00389
00390 ftp_close(ftp_con);
00391
00392
00393
00394
00395
00396 p = destination;
00397 for (i=0 ; i<5 && p != NULL ; i++) {
00398 p = strchr(p, ',');
00399 if (*p == ',')
00400 p++;
00401 }
00402 if (p != NULL) {
00403 strlcpy(filename, p, sizeof(filename));
00404 if (strchr(filename, ','))
00405 *strchr(filename, ',') = 0;
00406 } else
00407 strlcpy(filename, destination, sizeof(filename));
00408
00409
00410 if (filename[0] == '.')
00411 ftp_move(ftp_con, filename, filename+1);
00412
00413 ftp_bye(ftp_con);
00414 }
00415 #endif
00416 break;
00417 }
00418 if (status != SS_SUCCESS)
00419 return status;
00420 return (MD_SUCCESS);
00421 }
00422
00423
00424 INT md_dev_os_read(INT handle, INT type, void *prec, DWORD nbytes, DWORD * readn)
00425
00426
00427
00428
00429
00430
00431
00432
00433
00434
00435
00436
00437
00438
00439 {
00440 INT status;
00441 if (type == LOG_TYPE_DISK)
00442
00443 {
00444 *readn = read(handle, prec, nbytes);
00445 if (*readn <= 0)
00446 status = SS_FILE_ERROR;
00447 else
00448 status = SS_SUCCESS;
00449 return status;
00450 }
00451
00452 #ifdef OS_UNIX
00453 else if (type == LOG_TYPE_TAPE) {
00454 *readn = read(handle, prec, nbytes);
00455 if (*readn <= 0)
00456 status = SS_FILE_ERROR;
00457 else
00458 status = SS_SUCCESS;
00459 return status;
00460 }
00461 #endif
00462
00463 #ifdef OS_WINNT
00464 else if (type == LOG_TYPE_TAPE) {
00465 if (!ReadFile((HANDLE) handle, prec, nbytes, readn, NULL))
00466 status = GetLastError();
00467 else
00468 status = SS_SUCCESS;
00469 if (status == ERROR_NO_DATA_DETECTED)
00470 status = SS_END_OF_TAPE;
00471
00472 return status;
00473 }
00474 #endif
00475 else
00476 return SS_SUCCESS;
00477 }
00478
00479
00480 INT md_dev_os_write(INT handle, INT type, void *prec, DWORD nbytes, DWORD * written)
00481
00482
00483
00484
00485
00486
00487
00488
00489
00490
00491
00492
00493
00494
00495
00496 {
00497 INT status;
00498 if (type == LOG_TYPE_DISK)
00499 #ifdef OS_WINNT
00500 {
00501 WriteFile((HANDLE) handle, (char *) prec, nbytes, written, NULL);
00502 status = *written == nbytes ? SS_SUCCESS : SS_FILE_ERROR;
00503 return status;
00504 }
00505 #else
00506 {
00507 status = *written = write(handle, (char *) prec, nbytes) == (INT) nbytes ? SS_SUCCESS : SS_FILE_ERROR;
00508 return status;
00509 }
00510 #endif
00511 else if (type == LOG_TYPE_TAPE) {
00512 #ifdef OS_UNIX
00513 do {
00514 status = write(handle, (char *) prec, nbytes);
00515 } while (status == -1 && errno == EINTR);
00516 *written = status;
00517 if (*written != nbytes) {
00518 cm_msg(MERROR, "any_dev_os_write", strerror(errno));
00519 if (errno == EIO)
00520 return SS_IO_ERROR;
00521 if (errno == ENOSPC)
00522 return SS_NO_SPACE;
00523 else
00524 return SS_TAPE_ERROR;
00525 }
00526 #endif
00527
00528 #ifdef OS_WINNT
00529 WriteFile((HANDLE) handle, (char *) prec, nbytes, written, NULL);
00530 if (*written != nbytes) {
00531 status = GetLastError();
00532 cm_msg(MERROR, "any_dev_os_write", "error %d", status);
00533 return SS_IO_ERROR;
00534 }
00535 return SS_SUCCESS;
00536 #endif
00537 } else if (type == LOG_TYPE_FTP)
00538 #ifdef HAVE_FTPLIB
00539 {
00540 *written = status = ftp_send(ftp_con->data, (char *) prec,
00541 (int) nbytes) == (int) nbytes ? SS_SUCCESS : SS_FILE_ERROR;
00542 return status;
00543 }
00544 #else
00545 {
00546 cm_msg(MERROR, "mdsupport", "FTP support not included");
00547 return SS_IO_ERROR;
00548 }
00549 #endif
00550 return SS_SUCCESS;
00551 }
00552
00553
00554 INT md_physrec_get(INT data_fmt, void **precord, DWORD * readn)
00555
00556
00557
00558
00559
00560
00561
00562
00563
00564
00565
00566 {
00567 *precord = my.pmp;
00568 if (data_fmt == FORMAT_MIDAS) {
00569 return midas_physrec_get(*precord, readn);
00570 } else
00571 return MD_UNKNOWN_FORMAT;
00572 }
00573
00574
00575 INT md_log_write(INT handle, INT data_fmt, INT type, void *prec, DWORD nbytes)
00576
00577
00578
00579
00580
00581
00582
00583
00584
00585
00586
00587
00588
00589
00590
00591 {
00592 INT status;
00593 DWORD written;
00594
00595 status = data_fmt;
00596
00597 status = md_dev_os_write(handle, type, prec, nbytes, &written);
00598 return status;
00599 }
00600
00601
00602 INT md_physrec_skip(INT data_fmt, INT bl)
00603
00604
00605
00606
00607
00608
00609
00610
00611
00612
00613
00614
00615
00616
00617 {
00618 INT status;
00619
00620 if (data_fmt == FORMAT_MIDAS) {
00621 status = midas_event_skip(bl);
00622 return MD_SUCCESS;
00623 } else
00624 return MD_UNKNOWN_FORMAT;
00625 }
00626
00627
00628 INT midas_event_skip(INT evtn)
00629
00630
00631
00632
00633
00634
00635
00636
00637
00638
00639
00640 {
00641 void *pevent;
00642 DWORD size;
00643
00644 size = MAX_EVENT_SIZE;
00645 if (evtn == -1) {
00646
00647 return MD_SUCCESS;
00648 }
00649 while (midas_event_get(&pevent, &size) == MD_SUCCESS) {
00650 if ((INT) my.evtn < evtn) {
00651 printf("Skipping event_# ... ");
00652 printf("%d \r", my.evtn);
00653 fflush(stdout);
00654 } else {
00655 printf("\n");
00656 return MD_SUCCESS;
00657 }
00658 }
00659 return MD_DONE;
00660 }
00661
00662
00663 INT md_physrec_display(INT data_fmt)
00664
00665
00666
00667
00668
00669
00670
00671
00672
00673
00674
00675
00676 {
00677
00678 if (data_fmt == FORMAT_MIDAS) {
00679 printf(">>> No physical record structure for Midas format <<<\n");
00680 return MD_DONE;
00681 } else if (data_fmt == FORMAT_YBOS) {
00682 assert(!"YBOS not supported anymore");
00683 return (MD_SUCCESS);
00684 } else
00685 return MD_UNKNOWN_FORMAT;
00686 }
00687
00688
00689 INT md_all_info_display(INT what)
00690
00691
00692
00693
00694
00695
00696
00697
00698
00699
00700
00701 {
00702 if (my.fmt == FORMAT_YBOS) {
00703 assert(!"YBOS not supported anymore");
00704 } else if (my.fmt == FORMAT_MIDAS) {
00705 DWORD mbn, run, ser;
00706 WORD id, msk;
00707 mbn = my.evtn;
00708 run = my.runn;
00709 id = my.pmh->event_id;
00710 msk = my.pmh->trigger_mask;
00711 ser = my.pmh->serial_number;
00712 switch (what) {
00713 case D_RECORD:
00714 case D_HEADER:
00715 printf(">>> No physical record structure for Midas format <<<\n");
00716 return MD_DONE;
00717 break;
00718 case D_EVTLEN:
00719 printf("Evt#%d- ", my.evtn);
00720 printf("%irun 0x%4.4uxid 0x%4.4uxmsk %5dmevt#", run, id, msk, mbn);
00721 printf("%5del/x%x %5dserial\n", my.evtlen, my.evtlen, ser);
00722 break;
00723 }
00724 }
00725 return MD_SUCCESS;
00726 }
00727
00728
00729 INT md_event_swap(INT data_fmt, void *pevent)
00730
00731
00732
00733
00734
00735
00736
00737
00738
00739
00740
00741 {
00742 INT status;
00743 BANK_HEADER *pbh;
00744
00745 if (data_fmt == FORMAT_MIDAS) {
00746 if ((((EVENT_HEADER *) pevent)->event_id == EVENTID_BOR) ||
00747 (((EVENT_HEADER *) pevent)->event_id == EVENTID_EOR) ||
00748 (((EVENT_HEADER *) pevent)->event_id == EVENTID_MESSAGE))
00749 return SS_SUCCESS;
00750 pbh = (BANK_HEADER *) (((EVENT_HEADER *) pevent) + 1);
00751 status = bk_swap(pbh, FALSE);
00752 return status == CM_SUCCESS ? MD_EVENT_NOT_SWAPPED : MD_SUCCESS;
00753 } else if (data_fmt == FORMAT_YBOS) {
00754 assert(!"YBOS not supported anymore");
00755 }
00756
00757 return MD_UNKNOWN_FORMAT;
00758 }
00759
00760
00761 INT md_event_get(INT data_fmt, void **pevent, DWORD * readn)
00762
00763
00764
00765
00766
00767
00768
00769
00770
00771
00772
00773 {
00774 INT status = 0;
00775
00776 *pevent = NULL;
00777 if (data_fmt == FORMAT_MIDAS)
00778 status = midas_event_get(pevent, readn);
00779 else if (data_fmt == FORMAT_YBOS)
00780 assert(!"YBOS not supported anymore");
00781 return (status);
00782 }
00783
00784
00785 void md_event_display(void *pevent, INT data_fmt, INT dsp_mode, INT dsp_fmt, char *bn)
00786
00787
00788
00789
00790
00791
00792
00793
00794
00795
00796
00797
00798
00799 {
00800 if (dsp_mode == DSP_RAW)
00801 md_raw_event_display(pevent, data_fmt, dsp_fmt);
00802 else if ((dsp_mode == DSP_BANK) || (dsp_mode == DSP_BANK_SINGLE))
00803 md_bank_event_display(pevent, data_fmt, dsp_fmt, dsp_mode, bn);
00804 else
00805 printf("mdsupport- Unknown format:%i\n", dsp_fmt);
00806 return;
00807 }
00808
00809
00810 void md_raw_event_display(void *pevent, INT data_fmt, INT dsp_fmt)
00811
00812
00813
00814
00815
00816
00817
00818
00819
00820
00821
00822
00823 {
00824 DWORD lrl = 0, *pevt = NULL, j, i, total = 0;
00825
00826 if (data_fmt == FORMAT_YBOS) {
00827 assert(!"YBOS not supported anymore");
00828 } else if (data_fmt == FORMAT_MIDAS) {
00829 lrl = ((((EVENT_HEADER *) pevent)->data_size) + sizeof(EVENT_HEADER)) / sizeof(DWORD);
00830 pevt = (DWORD *) pevent;
00831 }
00832
00833 for (i = 0; i < lrl; i += NLINE) {
00834 printf("%6.0d->: ", total);
00835 for (j = 0; j < NLINE; j++) {
00836 if ((i + j) < lrl) {
00837 if (dsp_fmt == DSP_DEC)
00838 printf("%8.i ", *pevt);
00839 else
00840 printf("%8.8x ", *pevt);
00841 pevt++;
00842 }
00843 }
00844 total += NLINE;
00845 printf("\n");
00846 }
00847 }
00848
00849
00850 void md_bank_event_display(void *pevent, INT data_fmt, INT dsp_fmt, INT dsp_mode, char *bn)
00851
00852
00853
00854
00855
00856
00857
00858
00859
00860
00861
00862
00863
00864 {
00865 char banklist[MD_STRING_BANKLIST_MAX + STRING_BANKLIST_MAX];
00866 DWORD *pdata, *pdata1;
00867 BANK_HEADER *pbh = NULL;
00868 BANK *pmbk;
00869 BANK32 *pmbk32;
00870 EVENT_HEADER *pheader;
00871 INT status, single = 0;
00872
00873 if (data_fmt == FORMAT_YBOS) {
00874 assert(!"YBOS not supported anymore");
00875 } else if (data_fmt == FORMAT_MIDAS) {
00876
00877 pheader = (EVENT_HEADER *) pevent;
00878 if (pheader->event_id == EVENTID_BOR ||
00879 pheader->event_id == EVENTID_EOR || pheader->event_id == EVENTID_MESSAGE)
00880 return;
00881
00882
00883 pbh = (BANK_HEADER *) (pheader + 1);
00884
00885
00886 if (dsp_mode == DSP_BANK_SINGLE) {
00887 bk_locate(pbh, bn, &pdata1);
00888 single = 1;
00889 }
00890
00891 if (!single)
00892 printf
00893 ("Evid:%4.4x- Mask:%4.4x- Serial:%i- Time:0x%x- Dsize:%i/0x%x",
00894 (WORD) pheader->event_id, (WORD) pheader->trigger_mask,
00895 pheader->serial_number, pheader->time_stamp, pheader->data_size, pheader->data_size);
00896
00897 if ((pbh->data_size + 8) == pheader->data_size) {
00898
00899 if (!single) {
00900
00901 status = bk_list((BANK_HEADER *) (pheader + 1), banklist);
00902 printf("\n#banks:%i - Bank list:-%s-\n", status, banklist);
00903 }
00904
00905
00906 if (bk_is32(pbh)) {
00907 pmbk32 = NULL;
00908 do {
00909 bk_iterate32(pbh, &pmbk32, &pdata);
00910 if (pmbk32 != NULL)
00911 if (single && (pdata == pdata1))
00912 midas_bank_display32(pmbk32, dsp_fmt);
00913 if (!single)
00914 if (pmbk32 != NULL)
00915 midas_bank_display32(pmbk32, dsp_fmt);
00916 } while (pmbk32 != NULL);
00917 } else {
00918 pmbk = NULL;
00919 do {
00920 bk_iterate(pbh, &pmbk, &pdata);
00921 if (pmbk != NULL)
00922 if (single && (pdata == pdata1))
00923 midas_bank_display(pmbk, dsp_fmt);
00924 if (!single)
00925 if (pmbk != NULL)
00926 midas_bank_display(pmbk, dsp_fmt);
00927 } while (pmbk != NULL);
00928 }
00929 } else {
00930 printf("\nFIXED event with Midas Header\n");
00931 md_raw_event_display(pevent, data_fmt, dsp_fmt);
00932 }
00933 }
00934
00935 return;
00936 }
00937
00938
00939 void md_bank_display(void *pmbh, void *pbk, INT data_fmt, INT dsp_mode, INT dsp_fmt)
00940
00941
00942
00943
00944
00945
00946
00947
00948
00949
00950
00951
00952
00953 {
00954 if (dsp_mode == DSP_RAW)
00955 md_raw_bank_display(pbk, data_fmt, dsp_fmt);
00956 else {
00957 if (data_fmt == FORMAT_MIDAS) {
00958 if (bk_is32(pmbh))
00959 midas_bank_display32((BANK32 *) pbk, dsp_fmt);
00960 else
00961 midas_bank_display((BANK *) pbk, dsp_fmt);
00962 } else if (data_fmt == FORMAT_YBOS)
00963 assert(!"YBOS not supported anymore");
00964 }
00965 return;
00966 }
00967
00968
00969 void md_raw_bank_display(void *pbank, INT data_fmt, INT dsp_fmt)
00970
00971
00972
00973
00974
00975
00976
00977
00978
00979
00980
00981
00982 {
00983 DWORD *pdata = NULL, lrl = 0, j, i;
00984
00985 if (data_fmt == FORMAT_YBOS) {
00986 assert(!"YBOS not supported any ore");
00987 } else if (data_fmt == FORMAT_MIDAS) {
00988 lrl = ((BANK *) pbank)->data_size >> 2;
00989 pdata = (DWORD *) ((BANK *) (pbank) + 1);
00990 }
00991
00992 for (i = 0; i < lrl; i += NLINE) {
00993 j = 0;
00994 printf("\n%4i-> ", i + j + 1);
00995 for (j = 0; j < NLINE; j++) {
00996 if ((i + j) < lrl) {
00997 if (dsp_fmt == DSP_DEC)
00998 printf("%8.i ", *((DWORD *) pdata));
00999 if (dsp_fmt == DSP_ASC)
01000 printf("%8.8x ", *((DWORD *) pdata));
01001 if (dsp_fmt == DSP_HEX)
01002 printf("%8.8x ", *((DWORD *) pdata));
01003 pdata++;
01004 }
01005 }
01006 }
01007 }
01008
01009
01010 INT midas_event_get(void **pevent, DWORD * readn)
01011
01012
01013
01014
01015
01016
01017
01018
01019
01020
01021
01022
01023
01024
01025
01026
01027 {
01028 INT status, leftover;
01029 DWORD fpart;
01030 static DWORD size = 0;
01031
01032
01033 *pevent = (char *) my.pmh;
01034 if (size == 0)
01035 size = my.size;
01036
01037
01038 if ((int) my.recn == -1) {
01039 status = midas_physrec_get((void *) my.pmp, &size);
01040 if (status != MD_SUCCESS)
01041 return (MD_DONE);
01042 }
01043
01044
01045
01046
01047
01048
01049
01050 if (((my.pmp + size) - (char *) my.pme) < (int) sizeof(EVENT_HEADER)) {
01051 fpart = (my.pmp + my.size) - (char *) my.pme;
01052 memcpy(my.pmh, my.pme, fpart);
01053 my.pmh = (EVENT_HEADER *) (((char *) my.pmh) + fpart);
01054 leftover = sizeof(EVENT_HEADER) - fpart;
01055 status = midas_physrec_get((void *) my.pmp, &size);
01056 if (status != MD_SUCCESS)
01057 return (MD_DONE);
01058 memset(my.pmp + size, -1, my.size - size);
01059 my.pme = (EVENT_HEADER *) my.pmp;
01060 memcpy(my.pmh, my.pme, leftover);
01061 my.pme = (EVENT_HEADER *) (((char *) my.pme) + leftover);
01062 my.pmh = (EVENT_HEADER *) * pevent;
01063 } else {
01064 memcpy(my.pmh, my.pme, sizeof(EVENT_HEADER));
01065 my.pme = (EVENT_HEADER *) (((char *) my.pme) + sizeof(EVENT_HEADER));
01066 }
01067
01068
01069
01070
01071 my.pmrd = (char *) (my.pmh + 1);
01072
01073
01074 if (my.pmh->event_id == -1)
01075 return MD_DONE;
01076
01077
01078 leftover = my.pmh->data_size;
01079
01080
01081 while (((my.pmp + size) - (char *) my.pme) < leftover) {
01082 fpart = (my.pmp + my.size) - (char *) my.pme;
01083 memcpy(my.pmrd, my.pme, fpart);
01084 my.pmrd += fpart;
01085 leftover -= fpart;
01086 status = midas_physrec_get((void *) my.pmp, &size);
01087 if (status != MD_SUCCESS)
01088 return (MD_DONE);
01089 memset(my.pmp + size, -1, my.size - size);
01090 my.pme = (EVENT_HEADER *) my.pmp;
01091 }
01092
01093
01094 *readn = my.evtlen = my.pmh->data_size + sizeof(EVENT_HEADER);
01095 memcpy(my.pmrd, my.pme, leftover);
01096 my.pme = (EVENT_HEADER *) (((char *) my.pme) + leftover);
01097 my.evtn++;
01098 return MD_SUCCESS;
01099 }
01100
01101
01102 INT midas_physrec_get(void *prec, DWORD * readn)
01103
01104
01105
01106
01107
01108
01109
01110
01111
01112
01113
01114
01115
01116
01117
01118
01119
01120 {
01121 INT status = 0;
01122
01123
01124 if (!my.zipfile) {
01125 status = md_dev_os_read(my.handle, my.type, prec, my.size, readn);
01126 } else {
01127 #ifdef HAVE_ZLIB
01128 *readn = gzread(filegz, (char *) prec, my.size);
01129 if (*readn <= 0)
01130 status = SS_FILE_ERROR;
01131 else
01132 status = SS_SUCCESS;
01133 #endif
01134 }
01135
01136 if (status != SS_SUCCESS) {
01137 return (MD_DONE);
01138 } else {
01139
01140 my.recn++;
01141 return (MD_SUCCESS);
01142 }
01143 }
01144
01145
01146 void midas_bank_display(BANK * pbk, INT dsp_fmt)
01147
01148
01149
01150
01151
01152
01153
01154
01155
01156
01157
01158 {
01159 char bank_name[5], strbktype[32];
01160 char *pdata, *pendbk;
01161 DWORD length_type = 0, lrl;
01162 INT type, i, j;
01163
01164 lrl = pbk->data_size;
01165 type = pbk->type & 0xff;
01166 bank_name[4] = 0;
01167 memcpy(bank_name, (char *) (pbk->name), 4);
01168 pdata = (char *) (pbk + 1);
01169
01170 j = 64;
01171 i = 1;
01172 strcpy(strbktype, "Unknown format");
01173 if (type == TID_DOUBLE) {
01174 length_type = sizeof(double);
01175 strcpy(strbktype, "double*8");
01176 }
01177 if (type == TID_FLOAT) {
01178 length_type = sizeof(float);
01179 strcpy(strbktype, "Real*4 (FMT machine dependent)");
01180 }
01181 if (type == TID_DWORD) {
01182 length_type = sizeof(DWORD);
01183 strcpy(strbktype, "Unsigned Integer*4");
01184 }
01185 if (type == TID_INT) {
01186 length_type = sizeof(INT);
01187 strcpy(strbktype, "Signed Integer*4");
01188 }
01189 if (type == TID_WORD) {
01190 length_type = sizeof(WORD);
01191 strcpy(strbktype, "Unsigned Integer*2");
01192 }
01193 if (type == TID_SHORT) {
01194 length_type = sizeof(short);
01195 strcpy(strbktype, "Signed Integer*2");
01196 }
01197 if (type == TID_BYTE) {
01198 length_type = sizeof(BYTE);
01199 strcpy(strbktype, "Unsigned Bytes");
01200 }
01201 if (type == TID_SBYTE) {
01202 length_type = sizeof(BYTE);
01203 strcpy(strbktype, "Signed Bytes");
01204 }
01205 if (type == TID_BOOL) {
01206 length_type = sizeof(DWORD);
01207 strcpy(strbktype, "Boolean");
01208 }
01209 if (type == TID_CHAR) {
01210 length_type = sizeof(char);
01211 strcpy(strbktype, "8 bit ASCII");
01212 }
01213 if (type == TID_STRUCT) {
01214 length_type = sizeof(char);
01215 strcpy(strbktype, "STRUCT (not supported->8 bits)");
01216 }
01217 if (type == TID_STRING) {
01218 length_type = sizeof(char);
01219 strcpy(strbktype, "String 8bit ASCII");
01220 }
01221
01222 printf("\nBank:%s Length: %i(I*1)/%i(I*4)/%i(Type) Type:%s",
01223 bank_name, lrl, lrl >> 2, lrl / (length_type == 0 ? 1 : length_type), strbktype);
01224
01225 pendbk = pdata + lrl;
01226 while (pdata < pendbk) {
01227 switch (type) {
01228 case TID_DOUBLE:
01229 if (j > 3) {
01230 printf("\n%4i-> ", i);
01231 j = 0;
01232 i += 4;
01233 }
01234 printf("%15.5le ", *((double *) pdata));
01235 pdata = (char *) (((double *) pdata) + 1);
01236 j++;
01237 break;
01238 case TID_FLOAT:
01239 if (j > 7) {
01240 printf("\n%4i-> ", i);
01241 j = 0;
01242 i += 8;
01243 }
01244 if ((dsp_fmt == DSP_DEC) || (dsp_fmt == DSP_UNK))
01245 printf("%8.3e ", *((float *) pdata));
01246 if (dsp_fmt == DSP_HEX)
01247 printf("0x%8.8x ", *((DWORD *) pdata));
01248 pdata = (char *) (((DWORD *) pdata) + 1);
01249 j++;
01250 break;
01251 case TID_DWORD:
01252 if (j > 7) {
01253 printf("\n%4i-> ", i);
01254 j = 0;
01255 i += 8;
01256 }
01257 if (dsp_fmt == DSP_DEC)
01258 printf("%8.1i ", *((DWORD *) pdata));
01259 if ((dsp_fmt == DSP_HEX) || (dsp_fmt == DSP_UNK))
01260 printf("0x%8.8x ", *((DWORD *) pdata));
01261 pdata = (char *) (((DWORD *) pdata) + 1);
01262 j++;
01263 break;
01264 case TID_INT:
01265 if (j > 7) {
01266 printf("\n%4i-> ", i);
01267 j = 0;
01268 i += 8;
01269 }
01270 if ((dsp_fmt == DSP_DEC) || (dsp_fmt == DSP_UNK))
01271 printf("%8.1i ", *((DWORD *) pdata));
01272 if (dsp_fmt == DSP_HEX)
01273 printf("0x%8.8x ", *((DWORD *) pdata));
01274 pdata = (char *) (((DWORD *) pdata) + 1);
01275 j++;
01276 break;
01277 case TID_WORD:
01278 if (j > 7) {
01279 printf("\n%4i-> ", i);
01280 j = 0;
01281 i += 8;
01282 }
01283 if (dsp_fmt == DSP_DEC)
01284 printf("%5.1i ", *((WORD *) pdata));
01285 if ((dsp_fmt == DSP_HEX) || (dsp_fmt == DSP_UNK))
01286 printf("0x%4.4x ", *((WORD *) pdata));
01287 pdata = (char *) (((WORD *) pdata) + 1);
01288 j++;
01289 break;
01290 case TID_SHORT:
01291 if (j > 7) {
01292 printf("\n%4i-> ", i);
01293 j = 0;
01294 i += 8;
01295 }
01296 if ((dsp_fmt == DSP_DEC) || (dsp_fmt == DSP_UNK))
01297 printf("%5.1i ", *((short *) pdata));
01298 if (dsp_fmt == DSP_HEX)
01299 printf("0x%4.4x ", *((short *) pdata));
01300 pdata = (char *) (((short *) pdata) + 1);
01301 j++;
01302 break;
01303 case TID_BYTE:
01304 case TID_STRUCT:
01305 if (j > 15) {
01306 printf("\n%4i-> ", i);
01307 j = 0;
01308 i += 16;
01309 }
01310 if (dsp_fmt == DSP_DEC)
01311 printf("%4.i ", *((BYTE *) pdata));
01312 if ((dsp_fmt == DSP_HEX) || (dsp_fmt == DSP_UNK))
01313 printf("0x%2.2x ", *((BYTE *) pdata));
01314 pdata++;
01315 j++;
01316 break;
01317 case TID_SBYTE:
01318 if (j > 15) {
01319 printf("\n%4i-> ", i);
01320 j = 0;
01321 i += 16;
01322 }
01323 if ((dsp_fmt == DSP_DEC) || (dsp_fmt == DSP_UNK))
01324 printf("%4.i ", *((BYTE *) pdata));
01325 if (dsp_fmt == DSP_HEX)
01326 printf("0x%2.2x ", *((BYTE *) pdata));
01327 pdata++;
01328 j++;
01329 break;
01330 case TID_BOOL:
01331 if (j > 15) {
01332 printf("\n%4i-> ", i);
01333 j = 0;
01334 i += 16;
01335 }
01336 (*((BOOL *) pdata) != 0) ? printf("Y ") : printf("N ");
01337 pdata = (char *) (((DWORD *) pdata) + 1);
01338 j++;
01339 break;
01340 case TID_CHAR:
01341 case TID_STRING:
01342 if (j > 15) {
01343 printf("\n%4i-> ", i);
01344 j = 0;
01345 i += 16;
01346 }
01347 if (dsp_fmt == DSP_DEC)
01348 printf("%3.i ", *((BYTE *) pdata));
01349 if ((dsp_fmt == DSP_ASC) || (dsp_fmt == DSP_UNK))
01350 printf("%1.1s ", (char *) pdata);
01351 if (dsp_fmt == DSP_HEX)
01352 printf("0x%2.2x ", *((BYTE *) pdata));
01353 pdata++;
01354 j++;
01355 break;
01356 default:
01357 printf("bank type not supported (%d)\n", type);
01358 return;
01359 break;
01360 }
01361 }
01362 printf("\n");
01363 return;
01364 }
01365
01366
01367 void midas_bank_display32(BANK32 * pbk, INT dsp_fmt)
01368
01369
01370
01371
01372
01373
01374
01375
01376
01377
01378
01379
01380 {
01381 char bank_name[5], strbktype[32];
01382 char *pdata, *pendbk;
01383 DWORD length_type = 0, lrl;
01384 INT type, i, j;
01385
01386 lrl = pbk->data_size;
01387 type = pbk->type & 0xff;
01388 bank_name[4] = 0;
01389 memcpy(bank_name, (char *) (pbk->name), 4);
01390 pdata = (char *) (pbk + 1);
01391
01392 j = 64;
01393 i = 1;
01394 strcpy(strbktype, "Unknown format");
01395 if (type == TID_DOUBLE) {
01396 length_type = sizeof(double);
01397 strcpy(strbktype, "double*8");
01398 }
01399 if (type == TID_FLOAT) {
01400 length_type = sizeof(float);
01401 strcpy(strbktype, "Real*4 (FMT machine dependent)");
01402 }
01403 if (type == TID_DWORD) {
01404 length_type = sizeof(DWORD);
01405 strcpy(strbktype, "Unsigned Integer*4");
01406 }
01407 if (type == TID_INT) {
01408 length_type = sizeof(INT);
01409 strcpy(strbktype, "Signed Integer*4");
01410 }
01411 if (type == TID_WORD) {
01412 length_type = sizeof(WORD);
01413 strcpy(strbktype, "Unsigned Integer*2");
01414 }
01415 if (type == TID_SHORT) {
01416 length_type = sizeof(short);
01417 strcpy(strbktype, "Signed Integer*2");
01418 }
01419 if (type == TID_BYTE) {
01420 length_type = sizeof(BYTE);
01421 strcpy(strbktype, "Unsigned Bytes");
01422 }
01423 if (type == TID_SBYTE) {
01424 length_type = sizeof(BYTE);
01425 strcpy(strbktype, "Signed Bytes");
01426 }
01427 if (type == TID_BOOL) {
01428 length_type = sizeof(DWORD);
01429 strcpy(strbktype, "Boolean");
01430 }
01431 if (type == TID_CHAR) {
01432 length_type = sizeof(char);
01433 strcpy(strbktype, "8 bit ASCII");
01434 }
01435 if (type == TID_STRUCT) {
01436 length_type = sizeof(char);
01437 strcpy(strbktype, "STRUCT (not supported->8 bits)");
01438 }
01439 if (type == TID_STRING) {
01440 length_type = sizeof(char);
01441 strcpy(strbktype, "String 8bit ASCI");
01442 }
01443
01444 printf("\nBank:%s Length: %i(I*1)/%i(I*4)/%i(Type) Type:%s",
01445 bank_name, lrl, lrl >> 2, lrl / (length_type == 0 ? 1 : length_type), strbktype);
01446
01447 pendbk = pdata + lrl;
01448 while (pdata < pendbk) {
01449 switch (type) {
01450 case TID_DOUBLE:
01451 if (j > 3) {
01452 printf("\n%4i-> ", i);
01453 j = 0;
01454 i += 4;
01455 }
01456 printf("%15.5e ", *((double *) pdata));
01457 pdata = (char *) (((double *) pdata) + 1);
01458 j++;
01459 break;
01460 case TID_FLOAT:
01461 if (j > 7) {
01462 printf("\n%4i-> ", i);
01463 j = 0;
01464 i += 8;
01465 }
01466 if ((dsp_fmt == DSP_DEC) || (dsp_fmt == DSP_UNK))
01467 printf("%8.3e ", *((float *) pdata));
01468 if (dsp_fmt == DSP_HEX)
01469 printf("0x%8.8x ", *((DWORD *) pdata));
01470 pdata = (char *) (((DWORD *) pdata) + 1);
01471 j++;
01472 break;
01473 case TID_DWORD:
01474 if (j > 7) {
01475 printf("\n%4i-> ", i);
01476 j = 0;
01477 i += 8;
01478 }
01479 if (dsp_fmt == DSP_DEC)
01480 printf("%8.1i ", *((DWORD *) pdata));
01481 if ((dsp_fmt == DSP_HEX) || (dsp_fmt == DSP_UNK))
01482 printf("0x%8.8x ", *((DWORD *) pdata));
01483 pdata = (char *) (((DWORD *) pdata) + 1);
01484 j++;
01485 break;
01486 case TID_INT:
01487 if (j > 7) {
01488 printf("\n%4i-> ", i);
01489 j = 0;
01490 i += 8;
01491 }
01492 if ((dsp_fmt == DSP_DEC) || (dsp_fmt == DSP_UNK))
01493 printf("%8.1i ", *((DWORD *) pdata));
01494 if (dsp_fmt == DSP_HEX)
01495 printf("0x%8.8x ", *((DWORD *) pdata));
01496 pdata = (char *) (((DWORD *) pdata) + 1);
01497 j++;
01498 break;
01499 case TID_WORD:
01500 if (j > 7) {
01501 printf("\n%4i-> ", i);
01502 j = 0;
01503 i += 8;
01504 }
01505 if (dsp_fmt == DSP_DEC)
01506 printf("%5.1i ", *((WORD *) pdata));
01507 if ((dsp_fmt == DSP_HEX) || (dsp_fmt == DSP_UNK))
01508 printf("0x%4.4x ", *((WORD *) pdata));
01509 pdata = (char *) (((WORD *) pdata) + 1);
01510 j++;
01511 break;
01512 case TID_SHORT:
01513 if (j > 7) {
01514 printf("\n%4i-> ", i);
01515 j = 0;
01516 i += 8;
01517 }
01518 if ((dsp_fmt == DSP_DEC) || (dsp_fmt == DSP_UNK))
01519 printf("%5.1i ", *((short *) pdata));
01520 if (dsp_fmt == DSP_HEX)
01521 printf("0x%4.4x ", *((short *) pdata));
01522 pdata = (char *) (((short *) pdata) + 1);
01523 j++;
01524 break;
01525 case TID_BYTE:
01526 case TID_STRUCT:
01527 if (j > 15) {
01528 printf("\n%4i-> ", i);
01529 j = 0;
01530 i += 16;
01531 }
01532 if (dsp_fmt == DSP_DEC)
01533 printf("%4.i ", *((BYTE *) pdata));
01534 if ((dsp_fmt == DSP_HEX) || (dsp_fmt == DSP_UNK))
01535 printf("0x%2.2x ", *((BYTE *) pdata));
01536 pdata++;
01537 j++;
01538 break;
01539 case TID_SBYTE:
01540 if (j > 15) {
01541 printf("\n%4i-> ", i);
01542 j = 0;
01543 i += 16;
01544 }
01545 if ((dsp_fmt == DSP_DEC) || (dsp_fmt == DSP_UNK))
01546 printf("%4.i ", *((BYTE *) pdata));
01547 if (dsp_fmt == DSP_HEX)
01548 printf("0x%2.2x ", *((BYTE *) pdata));
01549 pdata++;
01550 j++;
01551 break;
01552 case TID_BOOL:
01553 if (j > 15) {
01554 printf("\n%4i-> ", i);
01555 j = 0;
01556 i += 16;
01557 }
01558 (*((BOOL *) pdata) != 0) ? printf("Y ") : printf("N ");
01559 pdata = (char *) (((DWORD *) pdata) + 1);
01560 j++;
01561 break;
01562 case TID_CHAR:
01563 case TID_STRING:
01564 if (j > 15) {
01565 printf("\n%4i-> ", i);
01566 j = 0;
01567 i += 16;
01568 }
01569 if (dsp_fmt == DSP_DEC)
01570 printf("%3.i ", *((BYTE *) pdata));
01571 if (dsp_fmt == DSP_ASC || (dsp_fmt == DSP_UNK))
01572 printf("%1.1s ", (char *) pdata);
01573 if (dsp_fmt == DSP_HEX)
01574 printf("0x%2.2x ", *((BYTE *) pdata));
01575 pdata++;
01576 j++;
01577 break;
01578 default:
01579 printf("bank type not supported (%d)\n", type);
01580 return;
01581 break;
01582 }
01583 }
01584 printf("\n");
01585 return;
01586 }
01587
01588
01589
01590
01591
01592
01593