bool mubinccpy(backup_reg_list *list) { static readonly mval null_str = {MV_STR, 0, 0 , 0 , 0, 0}; int backup_socket; int4 size, size1, bsize, bm_num, hint, lmsize, save_blks, rsize, match, timeout, outsize; uint4 status, total_blks, bplmap, gds_ratio, blks_per_buff, counter, i, lcnt, read_size; uchar_ptr_t bm_blk_buff, ptr1, ptr1_top, ptr, ptr_top; char_ptr_t outptr, data_ptr; unsigned short rd_iosb[4], port; enum db_acc_method access; blk_hdr *bp, *bptr; struct FAB *fcb, temp_fab, mubincfab; struct RAB temp_rab, mubincrab; inc_header *outbuf; mval val; mstr *file; sgmnt_data_ptr_t header; char *common, addr[SA_MAXLEN + 1]; void (*common_write)(); void (*common_close)(); muinc_blk_hdr_ptr_t sblkh_p; trans_num blk_tn; block_id blk_num_base, blk_num; boolean_t is_bitmap_blk, backup_this_blk; enum db_ver dummy_odbv; int4 blk_bsiz; error_def(ERR_BCKUPBUFLUSH); error_def(ERR_COMMITWAITSTUCK); error_def(ERR_DBCCERR); error_def(ERR_ERRCALL); assert(list->reg == gv_cur_region); assert(incremental); /* Make sure inc_header can be same size on all platforms. Some platforms pad 8 byte aligned structures that end on a 4 byte boundary and some do not. It is critical that this structure is the same size on all platforms as it is sent across TCP connections when doing TCP backup. */ assert(0 == (SIZEOF(inc_header) % 8)); /* ================= Initialization and some checks ======================== */ header = list->backup_hdr; file = &(list->backup_file); if (!mubtomag) mubmaxblk = BACKUP_TEMPFILE_BUFF_SIZE; fcb = ((vms_gds_info *)(gv_cur_region->dyn.addr->file_cntl->file_info))->fab; if (list->tn >= header->trans_hist.curr_tn) { util_out_print("!/TRANSACTION number is greater than or equal to current transaction,", TRUE); util_out_print("No blocks backed up from database !AD", TRUE, fcb->fab$b_fns, fcb->fab$l_fna); return TRUE; } /* =========== open backup destination and define common_write ================= */ backup_write_errno = 0; backup_close_errno = 0; switch(list->backup_to) { case backup_to_file: /* open the file and define the common_write function */ mubincfab = cc$rms_fab; mubincfab.fab$b_fac = FAB$M_PUT; mubincfab.fab$l_fop = FAB$M_CBT | FAB$M_MXV | FAB$M_TEF | FAB$M_POS & (~FAB$M_RWC) & (~FAB$M_RWO); mubincfab.fab$l_fna = file->addr; mubincfab.fab$b_fns = file->len; mubincfab.fab$l_alq = cs_addrs->hdr->start_vbn + STARTING_BLOCKS * cs_addrs->hdr->blk_size / DISK_BLOCK_SIZE; mubincfab.fab$w_mrs = mubmaxblk; mubincfab.fab$w_deq = EXTEND_SIZE; switch (status = sys$create(&mubincfab)) { case RMS$_NORMAL: case RMS$_CREATED: case RMS$_SUPERSEDE: case RMS$_FILEPURGED: break; default: gtm_putmsg(status, 0, mubincfab.fab$l_stv); util_out_print("Error: Cannot create backup file !AD.", TRUE, mubincfab.fab$b_fns, mubincfab.fab$l_fna); return FALSE; } mubincrab = cc$rms_rab; mubincrab.rab$l_fab = &mubincfab; mubincrab.rab$l_rop = RAB$M_WBH; if (RMS$_NORMAL != (status = sys$connect(&mubincrab))) { gtm_putmsg(status, 0, mubincrab.rab$l_stv); util_out_print("Error: Cannot connect to backup file !AD.", TRUE, mubincfab.fab$b_fns, mubincfab.fab$l_fna); mubincfab.fab$l_fop |= FAB$M_DLT; sys$close(&mubincfab); return FALSE; } common = (char *)(&mubincrab); common_write = file_write; common_close = file_close; break; case backup_to_exec: util_out_print("Error: Backup to pipe is yet to be implemented.", TRUE); util_out_print("Error: Your request to backup database !AD to !AD is currently not valid.", TRUE, fcb->fab$b_fns, fcb->fab$l_fna, file->len, file->addr); return FALSE; case backup_to_tcp: iotcp_fillroutine(); /* parse it first */ switch (match = SSCANF(file->addr, "%[^:]:%hu", addr, &port)) { case 1 : port = DEFAULT_BKRS_PORT; case 2 : break; default : util_out_print("ERROR: A hostname has to be specified to backup through a TCP connection.", TRUE); return FALSE; } if ((0 == cli_get_int("NETTIMEOUT", &timeout)) || (0 > timeout)) timeout = DEFAULT_BKRS_TIMEOUT; if (0 > (backup_socket = tcp_open(addr, port, timeout, FALSE))) { util_out_print("ERROR: Cannot open tcp connection due to the above error.", TRUE); return FALSE; } common_write = tcp_write; common_close = tcp_close; common = (char *)(&backup_socket); break; default : util_out_print("ERROR: Backup format !UL not supported.", TRUE, list->backup_to); util_out_print("Error: Your request to backup database !AD to !AD is not valid.", TRUE, fcb->fab$b_fns, fcb->fab$l_fna, file->len, file->addr); return FALSE; } /* ============================= write inc_header =========================================== */ outptr = malloc(SIZEOF(inc_header)); outbuf = (inc_header *)outptr; MEMCPY_LIT(&outbuf->label[0], INC_HEADER_LABEL); stringpool.free = stringpool.base; op_horolog(&val); stringpool.free = stringpool.base; op_fnzdate(&val, &mu_bin_datefmt, &null_str, &null_str, &val); memcpy(&outbuf->date[0], val.str.addr, val.str.len); memcpy(&outbuf->reg[0], gv_cur_region->rname, MAX_RN_LEN); outbuf->start_tn = list->tn; outbuf->end_tn = header->trans_hist.curr_tn; outbuf->db_total_blks = header->trans_hist.total_blks; outbuf->blk_size = header->blk_size; outbuf->blks_to_upgrd = header->blks_to_upgrd; COMMON_WRITE(common, outptr, SIZEOF(inc_header)); free(outptr); if (mu_ctrly_occurred || mu_ctrlc_occurred) { error_mupip = TRUE; COMMON_CLOSE(common); util_out_print("WARNING: DB file !AD backup aborted.", TRUE, fcb->fab$b_fns, fcb->fab$l_fna); return FALSE; } /* ============================ read/write appropriate blocks =============================== */ bsize = header->blk_size; gds_ratio = bsize / DISK_BLOCK_SIZE; blks_per_buff = BACKUP_READ_SIZE / bsize; read_size = blks_per_buff * bsize; outsize = SIZEOF(muinc_blk_hdr) + bsize; outptr = (char_ptr_t)malloc(MAX(outsize, mubmaxblk)); sblkh_p = (muinc_blk_hdr_ptr_t)outptr; data_ptr = (char_ptr_t)(sblkh_p + 1); bp = (blk_hdr_ptr_t)mubbuf; bm_blk_buff = (uchar_ptr_t)malloc(SIZEOF(blk_hdr) + (BLKS_PER_LMAP * BML_BITS_PER_BLK / BITS_PER_UCHAR)); mubincrab.rab$l_rbf = outptr; save_blks = 0; access = header->acc_meth; memset(sblkh_p, 0, SIZEOF(*sblkh_p)); if (access == dba_bg) bp = mubbuf; else { ptr = cs_addrs->db_addrs[0] + (cs_addrs->hdr->start_vbn - 1) * DISK_BLOCK_SIZE; ptr_top = cs_addrs->db_addrs[1] + 1; } sblkh_p->use.bkup.ondsk_blkver = GDSNOVER; for (blk_num_base = 0; blk_num_base < header->trans_hist.total_blks; blk_num_base += blks_per_buff) { if (online && (0 != cs_addrs->shmpool_buffer->failed)) break; if (header->trans_hist.total_blks - blk_num_base < blks_per_buff) { blks_per_buff = header->trans_hist.total_blks - blk_num_base; read_size = blks_per_buff * bsize; } if (access == dba_bg) { if ((SS$_NORMAL != (status = sys$qiow(EFN$C_ENF, fcb->fab$l_stv, IO$_READVBLK, &rd_iosb, 0, 0, bp, read_size, cs_addrs->hdr->start_vbn + (gds_ratio * blk_num_base), 0, 0, 0))) || (SS$_NORMAL != (status = rd_iosb[0]))) { gtm_putmsg(VARLSTCNT(1) status); util_out_print("Error reading data from database !AD.", TRUE, fcb->fab$b_fns, fcb->fab$l_fna); free(outptr); free(bm_blk_buff); error_mupip = TRUE; COMMON_CLOSE(common); return FALSE; } } else { assert(dba_mm == access); bp = ptr + blk_num_base * bsize; } bptr = (blk_hdr *)bp; /* The blocks we back up will be whatever version they are. There is no implicit conversion in this part of the backup/restore. Since we aren't even looking at the blocks (and indeed some of these blocks could potentially contain unintialized garbage data), we set the block version to GDSNOVER to signal that the block version is unknown. The above applies to "regular" blocks but not to bitmap blocks which we know are initialized. Because we have to read the bitmap blocks, they will be converted as necessary. */ for (i = 0; i < blks_per_buff && ((blk_num_base + i) < header->trans_hist.total_blks); i++, bptr = (blk_hdr *)((char *)bptr + bsize)) { blk_num = blk_num_base + i; if (mu_ctrly_occurred || mu_ctrlc_occurred) { free(outptr); free(bm_blk_buff); error_mupip = TRUE; COMMON_CLOSE(common); util_out_print("WARNING: DB file !AD backup aborted.", TRUE, fcb->fab$b_fns, fcb->fab$l_fna); return FALSE; } /* Before we check if this block needs backing up, check if this is a new bitmap block or not. If it is, we can fall through and back it up as normal. But if this is NOT a bitmap block, use the existing bitmap to determine if this block has ever been allocated or not. If not, we don't want to even look at this block. It could be uninitialized which will just make things run slower if we go to read it and back it up. */ if (0 != ((BLKS_PER_LMAP - 1) & blk_num)) { /* Not a local bitmap block */ if (!gvcst_blk_ever_allocated(bm_blk_buff + SIZEOF(blk_hdr), ((blk_num * BML_BITS_PER_BLK) % (BLKS_PER_LMAP * BML_BITS_PER_BLK)))) continue; /* Bypass never-set blocks to avoid conversion problems */ is_bitmap_blk = FALSE; if (SIZEOF(v15_blk_hdr) <= (blk_bsiz = ((v15_blk_hdr_ptr_t)bptr)->bsiz)) { /* We have either a V4 block or uninitialized garbage */ if (blk_bsiz > bsize) /* This is not a valid V4 block so ignore it */ continue; blk_tn = ((v15_blk_hdr_ptr_t)bptr)->tn; } else { /* Assume V5 block */ if ((blk_bsiz = bptr->bsiz) > bsize) /* Not a valid V5 block either */ continue; blk_tn = bptr->tn; } } else { /* This is a bitmap block so save it into our bitmap block buffer. It is used as the basis of whether or not we have to process a given block or not. We process allocated and recycled blocks leaving free (never used) blocks alone as they have no data worth saving. But after saving it, upgrade it to the current format if necessary. */ is_bitmap_blk = TRUE; memcpy(bm_blk_buff, bptr, BM_SIZE(header->bplmap)); if (SIZEOF(v15_blk_hdr) <= ((v15_blk_hdr_ptr_t)bm_blk_buff)->bsiz) { /* This is a V4 format block -- needs upgrading */ status = gds_blk_upgrade(bm_blk_buff, bm_blk_buff, bsize, &dummy_odbv); if (SS_NORMAL != status) { free(outptr); free(bm_blk_buff); error_mupip = TRUE; COMMON_CLOSE(common); util_out_print("Error: Block 0x!XL is too large for automatic upgrade", TRUE, sblkh_p->blkid); return FALSE; } } assert(BM_SIZE(header->bplmap) == ((blk_hdr_ptr_t)bm_blk_buff)->bsiz); assert(LCL_MAP_LEVL == ((blk_hdr_ptr_t)bm_blk_buff)->levl); assert(gvcst_blk_is_allocated(bm_blk_buff + SIZEOF(blk_hdr), ((blk_num * BML_BITS_PER_BLK) % (BLKS_PER_LMAP * BML_BITS_PER_BLK)))); blk_bsiz = BM_SIZE(header->bplmap); blk_tn = ((blk_hdr_ptr_t)bm_blk_buff)->tn; } /* The conditions for backing up a block or ignoring it (in order of evaluation): 1) If blk is larger than size of db at time backup was initiated, we ignore the block. 2) Always backup blocks 0, 1, and 2 as these are the only blocks that can contain data and still have a transaction number of 0. 3) For bitmap blocks, if blks_to_upgrd != 0 and the TN is 0 and the block number >= last_blk_at_last_bkup, then backup the block. This way we get the correct version of the bitmap block in the restore (otherwise have no clue what version to create them in as bitmaps are created with a TN of 0 when before image journaling is enabled). 4) If the block TN is below our TN threshold, ignore the block. 5) Else if none of the above conditions, backup the block. */ if (online && (header->trans_hist.curr_tn <= blk_tn)) backup_this_blk = FALSE; else if (3 > blk_num || (is_bitmap_blk && 0 != header->blks_to_upgrd && (trans_num)0 == blk_tn && blk_num >= list->last_blk_at_last_bkup)) backup_this_blk = TRUE; else if ((blk_tn < list->tn)) backup_this_blk = FALSE; else backup_this_blk = TRUE; if (!backup_this_blk) { if (online) cs_addrs->nl->nbb = blk_num; continue; /* not applicable */ } sblkh_p->blkid = blk_num; memcpy(data_ptr, bptr, blk_bsiz); sblkh_p->valid_data = TRUE; /* Validation marker */ COMMON_WRITE(common, outptr, outsize); if (online) { if (0 != cs_addrs->shmpool_buffer->failed) break; cs_addrs->nl->nbb = blk_num; } save_blks++; } } /* ============================= write saved information for online backup ========================== */ if (online && (0 == cs_addrs->shmpool_buffer->failed)) { /* -------- make sure everyone involved finishes -------- */ cs_addrs->nl->nbb = BACKUP_NOT_IN_PROGRESS; /* By getting crit here, we ensure that there is no process still in transaction logic that sees (nbb != BACKUP_NOT_IN_PRORESS). After rel_crit(), any process that enters transaction logic will see (nbb == BACKUP_NOT_IN_PRORESS) because we just set it to that value. At this point, backup buffer is complete and there will not be any more new entries in the backup buffer until the next backup. */ grab_crit(gv_cur_region); assert(cs_data == cs_addrs->hdr); if (dba_bg == cs_data->acc_meth) { /* Now that we have crit, wait for any pending phase2 updates to finish. Since phase2 updates happen * outside of crit, we dont want them to keep writing to the backup temporary file even after the * backup is complete and the temporary file has been deleted. */ if (cs_addrs->nl->wcs_phase2_commit_pidcnt && !wcs_phase2_commit_wait(cs_addrs, NULL)) { gtm_putmsg(VARLSTCNT(7) ERR_COMMITWAITSTUCK, 5, process_id, 1, cs_addrs->nl->wcs_phase2_commit_pidcnt, DB_LEN_STR(gv_cur_region)); rel_crit(gv_cur_region); free(outptr); free(bm_blk_buff); error_mupip = TRUE; COMMON_CLOSE(common); return FALSE; } } if (debug_mupip) { util_out_print("MUPIP INFO: Current Transaction # at end of backup is 0x!16@XQ", TRUE, &cs_data->trans_hist.curr_tn); } rel_crit(gv_cur_region); counter = 0; while (0 != cs_addrs->shmpool_buffer->backup_cnt) { if (0 != cs_addrs->shmpool_buffer->failed) { util_out_print("Process !UL encountered the following error.", TRUE, cs_addrs->shmpool_buffer->failed); if (0 != cs_addrs->shmpool_buffer->backup_errno) gtm_putmsg(VARLSTCNT(1) cs_addrs->shmpool_buffer->backup_errno); free(outptr); free(bm_blk_buff); error_mupip = TRUE; COMMON_CLOSE(common); return FALSE; } backup_buffer_flush(gv_cur_region); if (++counter > MAX_BACKUP_FLUSH_TRY) { gtm_putmsg(VARLSTCNT(1) ERR_BCKUPBUFLUSH); free(outptr); free(bm_blk_buff); error_mupip = TRUE; COMMON_CLOSE(common); return FALSE; } if (counter & 0xF) wcs_sleep(counter); else { /* Force shmpool recovery to see if it can find the lost blocks */ if (!shmpool_lock_hdr(gv_cur_region)) { gtm_putmsg(VARLSTCNT(9) ERR_DBCCERR, 2, REG_LEN_STR(gv_cur_region), ERR_ERRCALL, 3, CALLFROM); free(outptr); free(bm_blk_buff); error_mupip = TRUE; COMMON_CLOSE(common); assert(FALSE); return FALSE;; } shmpool_abandoned_blk_chk(gv_cur_region, TRUE); shmpool_unlock_hdr(gv_cur_region); } } /* -------- Open the temporary file -------- */ temp_fab = cc$rms_fab; temp_fab.fab$b_fac = FAB$M_GET; temp_fab.fab$l_fna = list->backup_tempfile; temp_fab.fab$b_fns = strlen(list->backup_tempfile); temp_rab = cc$rms_rab; temp_rab.rab$l_fab = &temp_fab; for (lcnt = 1; MAX_OPEN_RETRY >= lcnt; lcnt++) { if (RMS$_FLK != (status = sys$open(&temp_fab, NULL, NULL))) break; wcs_sleep(lcnt); } if (RMS$_NORMAL != status) { gtm_putmsg(status, 0, temp_fab.fab$l_stv); util_out_print("WARNING: DB file !AD backup aborted.", TRUE, fcb->fab$b_fns, fcb->fab$l_fna); free(outptr); free(bm_blk_buff); error_mupip = TRUE; COMMON_CLOSE(common); return FALSE; } if (RMS$_NORMAL != (status = sys$connect(&temp_rab))) { gtm_putmsg(status, 0, temp_rab.rab$l_stv); util_out_print("WARNING: DB file !AD backup aborted.", TRUE, fcb->fab$b_fns, fcb->fab$l_fna); free(outptr); free(bm_blk_buff); error_mupip = TRUE; COMMON_CLOSE(common); return FALSE; } /* -------- read and write every record in the temporary file -------- */ while (1) { temp_rab.rab$w_usz = outsize; temp_rab.rab$l_ubf = outptr; status = sys$get(&temp_rab); if (RMS$_NORMAL != status) { if (RMS$_EOF == status) status = RMS$_NORMAL; break; } assert(outsize == temp_rab.rab$w_rsz); /* Still validly sized blk? */ assert((outsize - SIZEOF(shmpool_blk_hdr)) >= ((blk_hdr_ptr_t)(outptr + SIZEOF(shmpool_blk_hdr)))->bsiz); COMMON_WRITE(common, outptr, temp_rab.rab$w_rsz); } if (RMS$_NORMAL != status) { gtm_putmsg(status, 0, temp_rab.rab$l_stv); util_out_print("WARNING: DB file !AD backup aborted.", TRUE, fcb->fab$b_fns, fcb->fab$l_fna); free(outptr); free(bm_blk_buff); error_mupip = TRUE; COMMON_CLOSE(common); return FALSE; } /* ---------------- Close the temporary file ----------------------- */ if (RMS$_NORMAL != (status = sys$close(&temp_fab))) { gtm_putmsg(status, 0, temp_fab.fab$l_stv); util_out_print("WARNING: DB file !AD backup aborted.", TRUE, fcb->fab$b_fns, fcb->fab$l_fna); free(outptr); free(bm_blk_buff); error_mupip = TRUE; COMMON_CLOSE(common); return FALSE; } } /* ============================= write end_msg and fileheader ======================================= */ if ((!online) || (0 == cs_addrs->shmpool_buffer->failed)) { MEMCPY_LIT(outptr, END_MSG); /* Although the write only need be of length SIZEOF(END_MSG) - 1 for file IO, if the write is going to TCP we have to write all these records with common length so just write the "regular" sized buffer. The extra garbage left over from the last write will be ignored as we key only on the this end text. */ COMMON_WRITE(common, outptr, outsize); ptr1 = header; size1 = ROUND_UP(SIZEOF(sgmnt_data), DISK_BLOCK_SIZE); ptr1_top = ptr1 + size1; for (;ptr1 < ptr1_top ; ptr1 += size1) { if ((size1 = ptr1_top - ptr1) > mubmaxblk) size1 = (mubmaxblk / DISK_BLOCK_SIZE) * DISK_BLOCK_SIZE; COMMON_WRITE(common, ptr1, size1); } MEMCPY_LIT(outptr, HDR_MSG); COMMON_WRITE(common, outptr, SIZEOF(HDR_MSG)); ptr1 = MM_ADDR(header); size1 = ROUND_UP(MASTER_MAP_SIZE(header), DISK_BLOCK_SIZE); ptr1_top = ptr1 + size1; for (;ptr1 < ptr1_top ; ptr1 += size1) { if ((size1 = ptr1_top - ptr1) > mubmaxblk) size1 = (mubmaxblk / DISK_BLOCK_SIZE) * DISK_BLOCK_SIZE; COMMON_WRITE(common, ptr1, size1); } MEMCPY_LIT(outptr, MAP_MSG); COMMON_WRITE(common, outptr, SIZEOF(MAP_MSG)); } /* ================== close backup destination, output and return ================================== */ if (online && (0 != cs_addrs->shmpool_buffer->failed)) { util_out_print("Process !UL encountered the following error.", TRUE, cs_addrs->shmpool_buffer->failed); if (0 != cs_addrs->shmpool_buffer->backup_errno) gtm_putmsg(VARLSTCNT(1) cs_addrs->shmpool_buffer->backup_errno); free(outptr); free(bm_blk_buff); error_mupip = TRUE; COMMON_CLOSE(common); return FALSE; } COMMON_CLOSE(common); free(outptr); free(bm_blk_buff); util_out_print("DB file !AD incrementally backed up in !AD", TRUE, fcb->fab$b_fns, fcb->fab$l_fna, file->len, file->addr); util_out_print("!UL blocks saved.", TRUE, save_blks); util_out_print("Transactions from 0x!16@XQ to 0x!16@XQ are backed up.", TRUE, &cs_addrs->shmpool_buffer->inc_backup_tn, &header->trans_hist.curr_tn); cs_addrs->hdr->last_inc_backup = header->trans_hist.curr_tn; if (record) cs_addrs->hdr->last_rec_backup = header->trans_hist.curr_tn; file_backed_up = TRUE; return TRUE; }
void op_svget(int varnum, mval *v) { io_log_name *tl; int count; gtm_uint64_t ucount; char *c1, *c2; mval *mvp; # ifdef UNIX d_rm_struct *d_rm; # endif DCL_THREADGBL_ACCESS; SETUP_THREADGBL_ACCESS; # if defined(UNIX) && defined(DEBUG) if (gtm_white_box_test_case_enabled && (WBTEST_HUGE_ALLOC == gtm_white_box_test_case_number)) { if (1 == gtm_white_box_test_case_count) totalAlloc = totalAllocGta = totalRmalloc = totalRallocGta = totalUsed = totalUsedGta = 0xffff; else if (2 == gtm_white_box_test_case_count) totalAlloc = totalAllocGta = totalRmalloc = totalRallocGta = totalUsed = totalUsedGta = 0xfffffff; else if (3 == gtm_white_box_test_case_count) { # ifdef GTM64 if (8 == SIZEOF(size_t)) totalAlloc = totalAllocGta = totalRmalloc = totalRallocGta = totalUsed = totalUsedGta = 0xfffffffffffffff; else # endif totalAlloc = totalAllocGta = totalRmalloc = totalRallocGta = totalUsed = totalUsedGta = 0xfffffff; } else totalAlloc = totalAllocGta = totalRmalloc = totalRallocGta = totalUsed = totalUsedGta = GTM64_ONLY(SIZEOF(size_t)) NON_GTM64_ONLY(SIZEOF(size_t) > 4 ? 4 : SIZEOF(size_t)); } # endif switch (varnum) { case SV_HOROLOG: op_horolog(v); break; case SV_ZGBLDIR: v->mvtype = MV_STR; v->str = dollar_zgbldir.str; break; case SV_PRINCIPAL: tl = dollar_principal ? dollar_principal : io_root_log_name->iod->trans_name; v->str.addr = tl->dollar_io; v->str.len = tl->len; /*** The following should be in the I/O code ***/ if (ESC == *v->str.addr) { if (5 > v->str.len) v->str.len = 0; else { v->str.addr += ESC_OFFSET; v->str.len -= ESC_OFFSET; } } s2pool(&(v->str)); v->mvtype = MV_STR; break; case SV_ZIO: v->mvtype = MV_STR; /* NOTE: This is **NOT** equivalent to : * io_curr_log_name->dollar_io */ v->str.addr = io_curr_device.in->trans_name->dollar_io; v->str.len = io_curr_device.in->trans_name->len; if (ESC == *v->str.addr) { if (5 > v->str.len) v->str.len = 0; else { v->str.addr += ESC_OFFSET; v->str.len -= ESC_OFFSET; } } s2pool(&(v->str)); break; case SV_JOB: *v = dollar_job; break; case SV_REFERENCE: get_reference(v); break; case SV_SYSTEM: *v = dollar_system; break; case SV_STORAGE: /* double2mval(v, getstorage()); Causes issues with unaligned stack on x86_64 - remove until fixed */ i2mval(v, getstorage()); break; case SV_TLEVEL: count = (int)dollar_tlevel; MV_FORCE_MVAL(v, count); break; case SV_TRESTART: MV_FORCE_MVAL(v, (int)((MAX_VISIBLE_TRESTART < dollar_trestart) ? MAX_VISIBLE_TRESTART : dollar_trestart)); break; case SV_X: count = (int)io_curr_device.out->dollar.x; MV_FORCE_MVAL(v, count); break; case SV_Y: count = (int)io_curr_device.out->dollar.y; MV_FORCE_MVAL(v, count); break; case SV_ZA: count = (int)io_curr_device.in->dollar.za; MV_FORCE_MVAL(v, count); break; case SV_ZB: c1 = (char *)io_curr_device.in->dollar.zb; c2 = c1 + SIZEOF(io_curr_device.in->dollar.zb); ENSURE_STP_FREE_SPACE(SIZEOF(io_curr_device.in->dollar.zb)); v->mvtype = MV_STR; v->str.addr = (char *)stringpool.free; while (c1 < c2 && *c1) *stringpool.free++ = *c1++; v->str.len = INTCAST((char *)stringpool.free - v->str.addr); break; case SV_ZC: /****THESE ARE DUMMY VALUES ONLY!!!!!!!!!!!!!!!!!****/ MV_FORCE_MVAL(v, 0); break; case SV_ZCMDLINE: get_command_line(v, TRUE); /* TRUE to indicate we want $ZCMDLINE (i.e. processed not actual command line) */ break; case SV_ZEOF: # ifdef UNIX if (rm == io_curr_device.in->type) { d_rm = (d_rm_struct *)io_curr_device.in->dev_sp; if (RM_READ != d_rm->lastop) { *v = literal_zero; break; } } # endif *v = io_curr_device.in->dollar.zeof ? literal_one : literal_zero; break; case SV_ZQUIT: *v = dollar_zquit_anyway ? literal_one : literal_zero; break; case SV_IO: v->str.addr = io_curr_device.in->name->dollar_io; v->str.len = io_curr_device.in->name->len; /*** The following should be in the I/O code ***/ if (ESC == *v->str.addr) { if (5 > v->str.len) v->str.len = 0; else { v->str.addr += ESC_OFFSET; v->str.len -= ESC_OFFSET; } } s2pool(&(v->str)); v->mvtype = MV_STR; break; case SV_PROMPT: v->mvtype = MV_STR; v->str.addr = (TREF(gtmprompt)).addr; v->str.len = (TREF(gtmprompt)).len; s2pool(&v->str); break; case SV_ZCOMPILE: v->mvtype = MV_STR; v->str = TREF(dollar_zcompile); s2pool(&(v->str)); break; case SV_ZDIR: setzdir(NULL, v); if (v->str.len != dollar_zdir.str.len || 0 != memcmp(v->str.addr, dollar_zdir.str.addr, v->str.len)) gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(6) ERR_ZDIROUTOFSYNC, 4, v->str.len, v->str.addr, dollar_zdir.str.len, dollar_zdir.str.addr); SKIP_DEVICE_IF_NOT_NEEDED(v); s2pool(&(v->str)); break; case SV_ZSTEP: *v = dollar_zstep; break; case SV_ZMODE: *v = TREF(dollar_zmode); break; case SV_ZMAXTPTIME: i2mval(v, TREF(dollar_zmaxtptime)); break; case SV_ZPOS: getzposition(v); break; case SV_ZPROC: getzprocess(); *v = dollar_zproc; break; case SV_ZLEVEL: count = dollar_zlevel(); MV_FORCE_MVAL(v, count); break; case SV_ZROUTINES: if (!TREF(zro_root)) zro_init(); v->mvtype = MV_STR; v->str = TREF(dollar_zroutines); s2pool(&(v->str)); break; case SV_ZSOURCE: v->mvtype = MV_STR; v->str = dollar_zsource.str; break; case SV_ZSTATUS: *v = dollar_zstatus; s2pool(&(v->str)); break; case SV_ZTRAP: v->mvtype = MV_STR; v->str = dollar_ztrap.str; assert(!v->str.len || !ztrap_explicit_null); s2pool(&(v->str)); break; case SV_DEVICE: get_dlr_device(v); break; case SV_KEY: get_dlr_key(v); break; case SV_ZVERSION: v->mvtype = MV_STR; v->str.addr = (char *)gtm_release_name; v->str.len = gtm_release_name_len; break; case SV_ZSYSTEM: MV_FORCE_MVAL(v, dollar_zsystem); break; case SV_ZCSTATUS: /* Maintain the external $ZCSTATUS == 1 for SUCCESS on UNIX while internal good is 0 */ MV_FORCE_MVAL(v, UNIX_ONLY((0 == TREF(dollar_zcstatus)) ? 1 : ) TREF(dollar_zcstatus)); break; case SV_ZEDITOR: MV_FORCE_MVAL(v, dollar_zeditor); break; case SV_QUIT: MV_FORCE_MVAL(v, dollar_quit()); break; case SV_ECODE: ecode_get(-1, v); break; case SV_ESTACK: count = (dollar_zlevel() - 1) - dollar_estack_delta.m[0]; MV_FORCE_MVAL(v, count); break; case SV_ETRAP: v->mvtype = MV_STR; v->str = dollar_etrap.str; assert(!v->str.len || !ztrap_explicit_null); s2pool(&(v->str)); break; case SV_STACK: count = (dollar_zlevel() - 1); MV_FORCE_MVAL(v, count); break; case SV_ZERROR: v->mvtype = MV_STR; v->str = dollar_zerror.str; s2pool(&(v->str)); break; case SV_ZYERROR: v->mvtype = MV_STR; v->str = dollar_zyerror.str; s2pool(&(v->str)); break; case SV_ZINTERRUPT: v->mvtype = MV_STR; v->str = dollar_zinterrupt.str; s2pool(&(v->str)); break; case SV_ZININTERRUPT: MV_FORCE_MVAL(v, dollar_zininterrupt); break; case SV_ZJOB: MV_FORCE_UMVAL(v, dollar_zjob); break; case SV_ZDATE_FORM: MV_FORCE_MVAL(v, TREF(zdate_form)); break; case SV_ZTEXIT: *v = dollar_ztexit; break; case SV_ZALLOCSTOR: ucount = (gtm_uint64_t)totalAlloc + (gtm_uint64_t)totalAllocGta; ui82mval(v, ucount); break; case SV_ZREALSTOR: ucount = (gtm_uint64_t)totalRmalloc + (gtm_uint64_t)totalRallocGta; ui82mval(v, ucount); break; case SV_ZUSEDSTOR: ucount = (gtm_uint64_t)totalUsed + (gtm_uint64_t)totalUsedGta; ui82mval(v, ucount); break; case SV_ZCHSET: v->mvtype = MV_STR; v->str = dollar_zchset; break; case SV_ZPATNUMERIC: v->mvtype = MV_STR; v->str = dollar_zpatnumeric; break; case SV_ZTNAME: case SV_ZTCODE: /* deprecated */ # ifdef GTM_TRIGGER if (NULL == dollar_ztname) memcpy(v, &literal_null, SIZEOF(mval)); else { v->mvtype = MV_STR; v->str.addr = dollar_ztname->addr; v->str.len = dollar_ztname->len; } break; # else rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP); # endif case SV_ZTDATA: # ifdef GTM_TRIGGER /* Value comes from GT.M, but it might be numeric and need conversion to a string */ assert(!dollar_ztdata || MV_DEFINED(dollar_ztdata)); if (NULL != dollar_ztdata) MV_FORCE_STR(dollar_ztdata); memcpy(v, (NULL != dollar_ztdata) ? dollar_ztdata : &literal_null, SIZEOF(mval)); break; # else rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP); # endif case SV_ZTDELIM: # ifdef GTM_TRIGGER assert(!dollar_ztdelim || MV_DEFINED(dollar_ztdelim)); if (NULL == dollar_ztdelim || !(MV_STR & dollar_ztdelim->mvtype) || (0 == dollar_ztdelim->str.len)) memcpy(v, &literal_null, SIZEOF(mval)); else memcpy(v, dollar_ztdelim, SIZEOF(mval)); break; # else rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP); # endif case SV_ZTOLDVAL: # ifdef GTM_TRIGGER /* Value comes from GT.M, but it might be numeric and need conversion to a string */ assert(!dollar_ztoldval || MV_DEFINED(dollar_ztoldval)); if (NULL != dollar_ztoldval) MV_FORCE_STR(dollar_ztoldval); memcpy(v, (NULL != dollar_ztoldval) ? dollar_ztoldval : &literal_null, SIZEOF(mval)); break; # else rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP); # endif case SV_ZTRIGGEROP: # ifdef GTM_TRIGGER /* Value comes from GT.M, but assert it's a string */ assert(!dollar_ztriggerop || (MV_STR & dollar_ztriggerop->mvtype)); memcpy(v, (NULL != dollar_ztriggerop) ? dollar_ztriggerop : &literal_null, SIZEOF(mval)); break; # else rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP); # endif case SV_ZTUPDATE: # ifdef GTM_TRIGGER /* Value comes from GT.M, but if there were no delims involved, the value will be undefined, and * we return a "literal_null". */ memcpy(v, ((NULL != dollar_ztupdate && (MV_STR & dollar_ztupdate->mvtype)) ? dollar_ztupdate : &literal_null), SIZEOF(mval)); break; # else rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP); # endif case SV_ZTVALUE: # ifdef GTM_TRIGGER /* Value comes from user-land so make sure things are proper */ assert(!dollar_ztvalue || MV_DEFINED(dollar_ztvalue)); if (NULL != dollar_ztvalue) MV_FORCE_STR(dollar_ztvalue); memcpy(v, (NULL != dollar_ztvalue) ? dollar_ztvalue : &literal_null, SIZEOF(mval)); break; # else rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP); # endif case SV_ZTWORMHOLE: # ifdef GTM_TRIGGER /* Value comes from user-land so make sure things are proper */ mvp = &dollar_ztwormhole; if (MV_DEFINED(mvp)) { MV_FORCE_STR(mvp); memcpy(v, mvp, SIZEOF(mval)); } else memcpy(v, &literal_null, SIZEOF(mval)); ztwormhole_used = TRUE; break; # else rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP); # endif case SV_ZTSLATE: # ifdef GTM_TRIGGER /* Value comes from user-land so make sure things are proper */ assert(MV_DEFINED((&dollar_ztslate))); mvp = &dollar_ztslate; MV_FORCE_STR(mvp); memcpy(v, mvp, SIZEOF(mval)); break; # else rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP); # endif case SV_ZTLEVEL: # ifdef GTM_TRIGGER MV_FORCE_MVAL(v, gtm_trigger_depth); break; # else rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP); # endif case SV_ZONLNRLBK: # ifdef UNIX count = TREF(dollar_zonlnrlbk); MV_FORCE_MVAL(v, count); break; # else rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP); # endif case SV_ZCLOSE: # ifdef UNIX count = TREF(dollar_zclose); MV_FORCE_MVAL(v, count); break; # else rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP); # endif case SV_ZKEY: get_dlr_zkey(v); break; default: assertpro(FALSE); } }
void mu_extract(void) { int stat_res, truncate_res; int reg_max_rec, reg_max_key, reg_max_blk, reg_std_null_coll; int iter, format, local_errno, int_nlen; boolean_t freeze = FALSE, logqualifier, success; char format_buffer[FORMAT_STR_MAX_SIZE], ch_set_name[MAX_CHSET_NAME], cli_buff[MAX_LINE], label_buff[LABEL_STR_MAX_SIZE], gbl_name_buff[MAX_MIDENT_LEN + 2]; /* 2 for null and '^' */ glist gl_head, *gl_ptr; gd_region *reg, *region_top; mu_extr_stats global_total, grand_total; uint4 item_code, devbufsiz, maxfield; unsigned short label_len, n_len, ch_set_len, buflen; unsigned char *outbuf, *outptr, *chptr, *leadptr; struct stat statbuf; mval val, curr_gbl_name, op_val, op_pars; mstr chset_mstr; gtm_chset_t saved_out_set; static unsigned char ochset_set = FALSE; static readonly unsigned char open_params_list[] = { (unsigned char)iop_noreadonly, (unsigned char)iop_nowrap, (unsigned char)iop_stream, (unsigned char)iop_eol }; static readonly unsigned char no_param = (unsigned char)iop_eol; coll_hdr extr_collhdr; error_def(ERR_NOSELECT); error_def(ERR_GTMASSERT); error_def(ERR_EXTRACTCTRLY); error_def(ERR_EXTRACTFILERR); error_def(ERR_MUPCLIERR); error_def(ERR_MUNOACTION); error_def(ERR_MUNOFINISH); error_def(ERR_RECORDSTAT); error_def(ERR_NULLCOLLDIFF); /* Initialize all local character arrays to zero before using */ memset(cli_buff, 0, sizeof(cli_buff)); memset(outfilename, 0, sizeof(outfilename)); memset(label_buff, 0, sizeof(label_buff)); memset(format_buffer, 0, sizeof(format_buffer)); active_device = io_curr_device.out; mu_outofband_setup(); if (CLI_PRESENT == cli_present("OCHSET")) { ch_set_len = sizeof(ch_set_name); if (cli_get_str("OCHSET", ch_set_name, &ch_set_len)) { if (0 == ch_set_len) mupip_exit(ERR_MUNOACTION); /* need to change to OPCHSET error when added */ ch_set_name[ch_set_len] = '\0'; #ifdef KEEP_zOS_EBCDIC if ( (iconv_t)0 != active_device->output_conv_cd) ICONV_CLOSE_CD(active_device->output_conv_cd); if (DEFAULT_CODE_SET != active_device->out_code_set) ICONV_OPEN_CD(active_device->output_conv_cd, INSIDE_CH_SET, ch_set_name); #else chset_mstr.addr = ch_set_name; chset_mstr.len = ch_set_len; SET_ENCODING(active_device->ochset, &chset_mstr); get_chset_desc(&chset_names[active_device->ochset]); #endif ochset_set = TRUE; } } logqualifier = (CLI_NEGATED != cli_present("LOG")); if (CLI_PRESENT == cli_present("FREEZE")) freeze = TRUE; n_len = sizeof(format_buffer); if (FALSE == cli_get_str("FORMAT", format_buffer, &n_len)) { n_len = sizeof("ZWR") - 1; memcpy(format_buffer, "ZWR", n_len); } int_nlen = n_len; lower_to_upper((uchar_ptr_t)format_buffer, (uchar_ptr_t)format_buffer, int_nlen); if (0 == memcmp(format_buffer, "ZWR", n_len)) format = MU_FMT_ZWR; else if (0 == memcmp(format_buffer, "GO", n_len)) { if (gtm_utf8_mode) { util_out_print("Extract error: GO format is not supported in UTF-8 mode. Use ZWR format.", TRUE); mupip_exit(ERR_MUPCLIERR); } format = MU_FMT_GO; } else if (0 == memcmp(format_buffer, "BINARY", n_len)) format = MU_FMT_BINARY; else { util_out_print("Extract error: bad format type", TRUE); mupip_exit(ERR_MUPCLIERR); } n_len = sizeof(cli_buff); if (FALSE == cli_get_str((char *)select_text, cli_buff, &n_len)) { n_len = 1; cli_buff[0] = '*'; } /* gv_select will select globals */ gv_select(cli_buff, n_len, freeze, (char *)select_text, &gl_head, ®_max_rec, ®_max_key, ®_max_blk); if (!gl_head.next) { rts_error(VARLSTCNT(1) ERR_NOSELECT); mupip_exit(ERR_NOSELECT); } /* For binary format, check whether all regions have same null collation order */ if (MU_FMT_BINARY == format) { for (reg = gd_header->regions, region_top = gd_header->regions + gd_header->n_regions, reg_std_null_coll = -1; reg < region_top ; reg++) { if (reg->open) { if (reg_std_null_coll != reg->std_null_coll) { if (reg_std_null_coll == -1) reg_std_null_coll = reg->std_null_coll; else { rts_error(VARLSTCNT(1) ERR_NULLCOLLDIFF); mupip_exit(ERR_NULLCOLLDIFF); } } } } assert(-1 != reg_std_null_coll); } grand_total.recknt = grand_total.reclen = grand_total.keylen = grand_total.datalen = 0; global_total.recknt = global_total.reclen = global_total.keylen = global_total.datalen = 0; n_len = sizeof(outfilename); if (FALSE == cli_get_str("FILE", outfilename, &n_len)) { rts_error(VARLSTCNT(1) ERR_MUPCLIERR); mupip_exit(ERR_MUPCLIERR); } if (-1 == Stat((char *)outfilename, &statbuf)) { if (ENOENT != errno) { local_errno = errno; perror("Error opening output file"); mupip_exit(local_errno); } } else { util_out_print("Error opening output file: !AD -- File exists", TRUE, n_len, outfilename); mupip_exit(ERR_MUNOACTION); } op_pars.mvtype = MV_STR; op_pars.str.len = sizeof(open_params_list); op_pars.str.addr = (char *)open_params_list; op_val.mvtype = MV_STR; op_val.str.len = filename_len = n_len; op_val.str.addr = (char *)outfilename; (*op_open_ptr)(&op_val, &op_pars, 0, 0); ESTABLISH(mu_extract_handler); op_use(&op_val, &op_pars); if (MU_FMT_BINARY == format) { /* binary header label format: * fixed length text, fixed length date & time, * fixed length max blk size, fixed length max rec size, fixed length max key size, fixed length std_null_coll * 32-byte padded user-supplied string */ outbuf = (unsigned char *)malloc(sizeof(BIN_HEADER_LABEL) + sizeof(BIN_HEADER_DATEFMT) - 1 + 4 * BIN_HEADER_NUMSZ + BIN_HEADER_LABELSZ); outptr = outbuf; MEMCPY_LIT(outptr, BIN_HEADER_LABEL); outptr += STR_LIT_LEN(BIN_HEADER_LABEL); stringpool.free = stringpool.base; op_horolog(&val); stringpool.free = stringpool.base; op_fnzdate(&val, (mval *)&mu_bin_datefmt, &null_str, &null_str, &val); memcpy(outptr, val.str.addr, val.str.len); outptr += val.str.len; WRITE_NUMERIC(reg_max_blk); WRITE_NUMERIC(reg_max_rec); WRITE_NUMERIC(reg_max_key); WRITE_NUMERIC(reg_std_null_coll); if (gtm_utf8_mode) { MEMCPY_LIT(outptr, UTF8_NAME); label_len = STR_LIT_LEN(UTF8_NAME); outptr[label_len++] = ' '; } else label_len = 0; buflen = sizeof(label_buff); if (FALSE == cli_get_str("LABEL", label_buff, &buflen)) { MEMCPY_LIT(&outptr[label_len], EXTR_DEFAULT_LABEL); buflen = STR_LIT_LEN(EXTR_DEFAULT_LABEL); } else memcpy(&outptr[label_len], label_buff, buflen); label_len += buflen; if (label_len > BIN_HEADER_LABELSZ) { /* Label size exceeds the space, so truncate the label and back off to the valid beginning (i.e. to the leading byte) of the last character that can entirely fit in the space */ label_len = BIN_HEADER_LABELSZ; chptr = &outptr[BIN_HEADER_LABELSZ]; UTF8_LEADING_BYTE(chptr, outptr, leadptr); assert(chptr - leadptr < 4); if (leadptr < chptr) label_len -= (chptr - leadptr); } outptr += label_len; for (iter = label_len; iter < BIN_HEADER_LABELSZ; iter++) *outptr++ = ' '; label_len = outptr - outbuf; if (!ochset_set) { #ifdef KEEP_zOS_EBCDIC /* extract ascii header for binary by default */ /* Do we need to restore it somewhere? */ saved_out_set = (io_curr_device.out)->out_code_set; (io_curr_device.out)->out_code_set = DEFAULT_CODE_SET; #else saved_out_set = (io_curr_device.out)->ochset; (io_curr_device.out)->ochset = CHSET_M; #endif } op_val.str.addr = (char *)(&label_len); op_val.str.len = sizeof(label_len); op_write(&op_val); op_val.str.addr = (char *)outbuf; op_val.str.len = label_len; op_write(&op_val); } else { assert((MU_FMT_GO == format) || (MU_FMT_ZWR == format)); label_len = sizeof(label_buff); if (FALSE == cli_get_str("LABEL", label_buff, &label_len)) { MEMCPY_LIT(label_buff, EXTR_DEFAULT_LABEL); label_len = STR_LIT_LEN(EXTR_DEFAULT_LABEL); } if (gtm_utf8_mode) { label_buff[label_len++] = ' '; MEMCPY_LIT(&label_buff[label_len], UTF8_NAME); label_len += STR_LIT_LEN(UTF8_NAME); } label_buff[label_len++] = '\n'; op_val.mvtype = MV_STR; op_val.str.len = label_len; op_val.str.addr = label_buff; op_write(&op_val); stringpool.free = stringpool.base; op_horolog(&val); stringpool.free = stringpool.base; op_fnzdate(&val, &datefmt, &null_str, &null_str, &val); op_val = val; op_val.mvtype = MV_STR; op_write(&op_val); if (MU_FMT_ZWR == format) { op_val.str.addr = " ZWR"; op_val.str.len = sizeof(" ZWR") - 1; op_write(&op_val); } op_wteol(1); } REVERT; ESTABLISH(mu_extract_handler1); success = TRUE; for (gl_ptr = gl_head.next; gl_ptr; gl_ptr = gl_ptr->next) { if (mu_ctrly_occurred) break; if (mu_ctrlc_occurred) { gbl_name_buff[0]='^'; memcpy(&gbl_name_buff[1], gl_ptr->name.str.addr, gl_ptr->name.str.len); gtm_putmsg(VARLSTCNT(8) ERR_RECORDSTAT, 6, gl_ptr->name.str.len + 1, gbl_name_buff, global_total.recknt, global_total.keylen, global_total.datalen, global_total.reclen); mu_ctrlc_occurred = FALSE; } gv_bind_name(gd_header, &gl_ptr->name.str); if (MU_FMT_BINARY == format) { label_len = sizeof(extr_collhdr); op_val.mvtype = MV_STR; op_val.str.addr = (char *)(&label_len); op_val.str.len = sizeof(label_len); op_write(&op_val); extr_collhdr.act = gv_target->act; extr_collhdr.nct = gv_target->nct; extr_collhdr.ver = gv_target->ver; op_val.str.addr = (char *)(&extr_collhdr); op_val.str.len = sizeof(extr_collhdr); op_write(&op_val); } /* Note: Do not change the order of the expression below. * Otherwise if success is FALSE, mu_extr_gblout() will not be called at all. * We want mu_extr_gblout() to be called irrespective of the value of success */ success = mu_extr_gblout(&gl_ptr->name, &global_total, format) && success; if (logqualifier) { gbl_name_buff[0]='^'; memcpy(&gbl_name_buff[1], gl_ptr->name.str.addr, gl_ptr->name.str.len); gtm_putmsg(VARLSTCNT(8) ERR_RECORDSTAT, 6, gl_ptr->name.str.len + 1, gbl_name_buff, global_total.recknt, global_total.keylen, global_total.datalen, global_total.reclen); mu_ctrlc_occurred = FALSE; } grand_total.recknt += global_total.recknt; if (grand_total.reclen < global_total.reclen) grand_total.reclen = global_total.reclen; if (grand_total.keylen < global_total.keylen) grand_total.keylen = global_total.keylen; if (grand_total.datalen < global_total.datalen) grand_total.datalen = global_total.datalen; } op_val.mvtype = op_pars.mvtype = MV_STR; op_val.str.addr = (char *)outfilename;; op_val.str.len = filename_len; op_pars.str.len = sizeof(no_param); op_pars.str.addr = (char *)&no_param; op_close(&op_val, &op_pars); REVERT; if (mu_ctrly_occurred) { gtm_putmsg(VARLSTCNT(1) ERR_EXTRACTCTRLY); mupip_exit(ERR_MUNOFINISH); } gtm_putmsg(VARLSTCNT(8) ERR_RECORDSTAT, 6, LEN_AND_LIT(gt_lit), grand_total.recknt, grand_total.keylen, grand_total.datalen, grand_total.reclen); if (MU_FMT_BINARY == format) { /* truncate the last newline charactor flushed by op_close */ STAT_FILE((char *)outfilename, &statbuf, stat_res); if (-1 == stat_res) rts_error(VARLSTCNT(1) errno); TRUNCATE_FILE((const char *)outfilename, statbuf.st_size - 1, truncate_res); if (-1 == truncate_res) rts_error(VARLSTCNT(1) errno); } mupip_exit(success ? SS_NORMAL : ERR_MUNOFINISH); }
void zshow_svn(zshow_out *output) { mstr x; mval var, zdir; io_log_name *tl; stack_frame *fp; int count, save_dollar_zlevel; char *c1, *c2; char zdir_error[3 * GTM_MAX_DIR_LEN + 128]; /* PATH_MAX + "->" + GTM-W-ZDIROUTOFSYNC, <text of ZDIROUTOFSYNC> */ error_def(ERR_ZDIROUTOFSYNC); /* SV_DEVICE */ get_dlr_device(&var); ZS_VAR_EQU(&x, device_text); mval_write(output, &var, TRUE); /* SV_ECODE */ ecode_get(-1, &var); ZS_VAR_EQU(&x, ecode_text); mval_write(output, &var, TRUE); /* SV_ESTACK */ save_dollar_zlevel = dollar_zlevel(); count = (save_dollar_zlevel - 1) - dollar_estack_delta.m[0]; MV_FORCE_MVAL(&var, count); ZS_VAR_EQU(&x, estack_text); mval_write(output, &var, TRUE); /* SV_ETRAP */ var.mvtype = MV_STR; var.str = dollar_etrap.str; ZS_VAR_EQU(&x, etrap_text); mval_write(output, &var, TRUE); /* SV_HOROLOG */ op_horolog(&var); ZS_VAR_EQU(&x, horolog_text); mval_write(output, &var, TRUE); /* SV_IO */ var.str.addr = io_curr_device.in->name->dollar_io; var.str.len = io_curr_device.in->name->len; /*** The following should be in the I/O code ***/ if (ESC == *var.str.addr) { if (5 > var.str.len) var.str.len = 0; else { var.str.addr += ESC_OFFSET; var.str.len -= ESC_OFFSET; } } var.mvtype = MV_STR; ZS_VAR_EQU(&x, io_text); mval_write(output, &var, TRUE); /* SV_JOB */ ZS_VAR_EQU(&x, job_text); mval_write(output, &dollar_job, TRUE); /* SV_KEY */ get_dlr_key(&var); ZS_VAR_EQU(&x, key_text); mval_write(output, &var, TRUE); /* SV_PRINCIPAL */ if (dollar_principal) tl = dollar_principal; else tl = io_root_log_name->iod->trans_name; var.str.addr = tl->dollar_io; var.str.len = tl->len; /*** The following should be in the I/O code ***/ if (ESC == *var.str.addr) { if (5 > var.str.len) var.str.len = 0; else { var.str.addr += ESC_OFFSET; var.str.len -= ESC_OFFSET; } } var.mvtype = MV_STR; ZS_VAR_EQU(&x, principal_text); mval_write(output, &var, TRUE); /* SV_QUIT */ count = ((NULL == get_ret_targ()) ? 0 : 1); MV_FORCE_MVAL(&var, count); ZS_VAR_EQU(&x, quit_text); mval_write(output, &var, TRUE); /* SV_REFERENCE */ get_reference(&var); ZS_VAR_EQU(&x, reference_text); mval_write(output, &var, TRUE); /* SV_STACK */ count = (save_dollar_zlevel - 1); MV_FORCE_MVAL(&var, count); ZS_VAR_EQU(&x, stack_text); mval_write(output, &var, TRUE); /* SV_STORAGE */ i2mval(&var, getstorage()); ZS_VAR_EQU(&x, storage_text); mval_write(output, &var, TRUE); /* SV_SYSTEM */ var.mvtype = MV_STR; var.str = dollar_system.str; ZS_VAR_EQU(&x, system_text); mval_write(output, &var, TRUE); /* SV_TEST */ i2mval(&var, (int)op_dt_get()); ZS_VAR_EQU(&x, test_text); mval_write(output, &var, TRUE); /* SV_TLEVEL */ count = (int)dollar_tlevel; MV_FORCE_MVAL(&var, count); ZS_VAR_EQU(&x, tlevel_text); mval_write(output, &var, TRUE); /* SV_TRESTART */ MV_FORCE_MVAL(&var, (int)((MAX_VISIBLE_TRESTART < dollar_trestart) ? MAX_VISIBLE_TRESTART : dollar_trestart)); ZS_VAR_EQU(&x, trestart_text); mval_write(output, &var, TRUE); /* SV_X */ count = (int)io_curr_device.out->dollar.x; MV_FORCE_MVAL(&var, count); ZS_VAR_EQU(&x, x_text); mval_write(output, &var, TRUE); /* SV_Y */ count = (int)io_curr_device.out->dollar.y; MV_FORCE_MVAL(&var, count); ZS_VAR_EQU(&x, y_text); mval_write(output, &var, TRUE); /* SV_ZA */ count = (int)io_curr_device.in->dollar.za; MV_FORCE_MVAL(&var, count); ZS_VAR_EQU(&x, za_text); mval_write(output, &var, TRUE); /* SV_ZB */ c1 = (char *)io_curr_device.in->dollar.zb; c2 = c1 + sizeof(io_curr_device.in->dollar.zb); var.mvtype = MV_STR; var.str.addr = (char *)io_curr_device.in->dollar.zb; while (c1 < c2 && *c1) c1++; var.str.len = (char *)c1 - var.str.addr; ZS_VAR_EQU(&x, zb_text); mval_write(output, &var, TRUE); /* SV_ZCMDLINE */ get_command_line(&var, TRUE); /* TRUE to indicate we want $ZCMDLINE (i.e. processed not actual command line) */ ZS_VAR_EQU(&x, zcmdline_text); mval_write(output, &var, TRUE); /* SV_ZCOMPILE */ var.mvtype = MV_STR; var.str = dollar_zcompile; ZS_VAR_EQU(&x, zcompile_text); mval_write(output, &var, TRUE); /* SV_ZCSTATUS */ MV_FORCE_MVAL(&var, dollar_zcstatus); ZS_VAR_EQU(&x, zcstatus_text); mval_write(output, &var, TRUE); /* SV_ZDATEFORM */ MV_FORCE_MVAL(&var, zdate_form); ZS_VAR_EQU(&x, zdate_form_text); mval_write(output, &var, TRUE); /* SV_ZDIR */ ZS_VAR_EQU(&x, zdirectory_text); setzdir(NULL, &zdir); if (zdir.str.len != dollar_zdir.str.len || 0 != memcmp(zdir.str.addr, dollar_zdir.str.addr, zdir.str.len)) { memcpy(zdir_error, zdir.str.addr, zdir.str.len); memcpy(&zdir_error[zdir.str.len], arrow_text, STR_LIT_LEN(arrow_text)); sgtm_putmsg(&zdir_error[zdir.str.len + STR_LIT_LEN(arrow_text)], VARLSTCNT(6) ERR_ZDIROUTOFSYNC, 4, zdir.str.len, zdir.str.addr, dollar_zdir.str.len, dollar_zdir.str.addr); zdir.str.addr = zdir_error; zdir.str.len = strlen(zdir_error) - 1; /* eliminate trailing '\n' */ } SKIP_DEVICE_IF_NOT_NEEDED(&zdir); mval_write(output, &zdir, TRUE); /* SV_ZEDITOR */ MV_FORCE_MVAL(&var, dollar_zeditor); ZS_VAR_EQU(&x, zeditor_text); mval_write(output, &var, TRUE); /* SV_ZEOF */ ZS_VAR_EQU(&x, zeof_text); mval_write(output, io_curr_device.in->dollar.zeof ? (mval *)&literal_one : (mval *)&literal_zero, TRUE); /* SV_ZERROR */ var.mvtype = MV_STR; var.str = dollar_zerror.str; ZS_VAR_EQU(&x, zerror_text); mval_write(output, &var, TRUE); /* SV_ZGBLDIR */ ZS_VAR_EQU(&x, zgbldir_text); mval_write(output, &dollar_zgbldir, TRUE); /* SV_ZININTERRUPT */ MV_FORCE_MVAL(&var, dollar_zininterrupt); ZS_VAR_EQU(&x, zininterrupt_text); mval_write(output, &var, TRUE); /* SV_ZINTERRUPT */ var.mvtype = MV_STR; var.str = dollar_zinterrupt.str; ZS_VAR_EQU(&x, zinterrupt_text); mval_write(output, &var, TRUE); /* SV_ZIO */ var.mvtype = MV_STR; /* NOTE: This is **NOT** equivalent to : * io_curr_log_name->dollar_io */ var.str.addr = io_curr_device.in->trans_name->dollar_io; var.str.len = io_curr_device.in->trans_name->len; if (*var.str.addr == ESC) { if (5 > var.str.len) var.str.len = 0; else { var.str.addr += ESC_OFFSET; var.str.len -= ESC_OFFSET; } } ZS_VAR_EQU(&x, zio_text); mval_write(output, &var, TRUE); /* SV_ZJOB */ MV_FORCE_ULONG_MVAL(&var, dollar_zjob); ZS_VAR_EQU(&x, zjob_text); mval_write(output, &var, TRUE); /* SV_ZLEVEL */ MV_FORCE_MVAL(&var, save_dollar_zlevel); ZS_VAR_EQU(&x, zlevel_text); mval_write(output, &var, TRUE); /* SV_ZMAXTPTIME */ MV_FORCE_MVAL(&var, dollar_zmaxtptime); ZS_VAR_EQU(&x, zmaxtptime_text); mval_write(output, &var, TRUE); /* SV_ZMODE */ ZS_VAR_EQU(&x, zmode_text); mval_write(output, &dollar_zmode, TRUE); /* SV_ZPOS */ getzposition(&var); ZS_VAR_EQU(&x, zpos_text); mval_write(output, &var, TRUE); /* SV_ZPROC */ ZS_VAR_EQU(&x, zproc_text); mval_write(output, &dollar_zproc, TRUE); /* SV_PROMPT */ var.mvtype = MV_STR; var.str.addr = gtmprompt.addr; var.str.len = gtmprompt.len; ZS_VAR_EQU(&x, zprompt_text); mval_write(output, &var, TRUE); /* SV_ZROUTINES */ if (!zro_root) zro_init(); var.mvtype = MV_STR; var.str = dollar_zroutines; ZS_VAR_EQU(&x, zroutines_text); mval_write(output, &var, TRUE); /* SV_ZSOURCE */ var.mvtype = MV_STR; var.str = dollar_zsource; ZS_VAR_EQU(&x, zsource_text); mval_write(output, &var, TRUE); /* SV_ZSTATUS */ ZS_VAR_EQU(&x, zstatus_text); mval_write(output, &dollar_zstatus, TRUE); /* SV_ZSTEP */ ZS_VAR_EQU(&x, zstep_text); mval_write(output, &dollar_zstep, TRUE); /* SV_ZSYSTEM */ MV_FORCE_MVAL(&var, dollar_zsystem); ZS_VAR_EQU(&x, zsystem_text); mval_write(output, &var, TRUE); /* SV_ZTEXIT */ var.mvtype = MV_STR; var.str = dollar_ztexit.str; ZS_VAR_EQU(&x, ztexit_text); mval_write(output, &var, TRUE); /* SV_ZTRAP */ var.mvtype = MV_STR; var.str = dollar_ztrap.str; ZS_VAR_EQU(&x, ztrap_text); mval_write(output, &var, TRUE); /* SV_ZVERSION */ var.mvtype = MV_STR; var.str.addr = (char *)>m_release_name[0]; var.str.len = gtm_release_name_len; ZS_VAR_EQU(&x, zversion_text); mval_write(output, &var, TRUE); /* SV_ZYERROR */ var.mvtype = MV_STR; var.str = dollar_zyerror.str; ZS_VAR_EQU(&x, zyerror_text); mval_write(output, &var, TRUE); }