int op_open(mval *device, mval *devparms, int timeout, mval *mspace) { LITREF unsigned char io_params_size[]; char buf1[MAX_TRANS_NAME_LEN]; /* buffer to hold translated name */ io_log_name *naml; /* logical record for passed name */ io_log_name *tl; /* logical record for translated name */ io_log_name *prev; /* logical record for removal search */ uint4 stat; /* status */ mstr tn; /* translated name */ error_def(LP_NOTACQ); /* bad license */ MV_FORCE_STR(device); MV_FORCE_STR(devparms); if (mspace) MV_FORCE_STR(mspace); if (timeout < 0) timeout = 0; assert((unsigned char)*devparms->str.addr < n_iops); naml = get_log_name(&device->str, INSERT); if (naml->iod != 0) tl = naml; else { #ifdef NOLICENSE licensed= TRUE; #else CRYPT_CHKSYSTEM; if (!licensed || LP_CONFIRM(lid, lkid)==LP_NOTACQ) licensed= FALSE; #endif switch(stat = trans_log_name(&device->str, &tn, &buf1[0])) { case SS_NORMAL: tl = get_log_name(&tn, INSERT); break; case SS_NOLOGNAM: tl = naml; break; default: for (prev = io_root_log_name, tl = prev->next; tl != 0; prev = tl, tl = tl->next) { if (naml == tl) { prev->next = tl->next; free(tl); break; } } rts_error(VARLSTCNT(1) stat); } } stat = io_open_try(naml, tl, devparms, timeout, mspace); return (stat); }
/* The third parameter is dummy to keep the inteface same as op_open */ int mu_op_open(mval *v, mval *p, int t, mval *mspace) { char buf1[MAX_TRANS_NAME_LEN]; /* buffer to hold translated name */ io_log_name *naml; /* logical record for passed name */ io_log_name *tl; /* logical record for translated name */ int4 stat; /* status */ mstr tn; /* translated name */ error_def(LP_NOTACQ); /* bad license */ error_def(ERR_LOGTOOLONG); MV_FORCE_STR(v); MV_FORCE_STR(p); if (mspace) MV_FORCE_STR(mspace); if (t < 0) t = 0; assert((unsigned char)*p->str.addr < n_iops); naml = get_log_name(&v->str, INSERT); if (naml->iod != 0) tl = naml; else { # ifdef NOLICENSE licensed= TRUE ; # else CRYPT_CHKSYSTEM; if (!licensed || LP_CONFIRM(lid,lkid)==LP_NOTACQ) { licensed= FALSE ; } # endif switch(stat = TRANS_LOG_NAME(&v->str, &tn, &buf1[0], sizeof(buf1), dont_sendmsg_on_log2long)) { case SS_NORMAL: tl = get_log_name(&tn, INSERT); break; case SS_NOLOGNAM: tl = naml; break; case SS_LOG2LONG: rts_error(VARLSTCNT(5) ERR_LOGTOOLONG, 3, v->str.len, v->str.addr, sizeof(buf1) - 1); break; default: rts_error(VARLSTCNT(1) stat); } } stat = mu_open_try(naml, tl, p, mspace); return (stat); }
void stdlog(char *fmt,...) /*=======================*/ { FILE *F; char buf[4086]=""; va_list argptr; va_start(argptr, fmt); vsprintf(buf, fmt, argptr); va_end(argptr); F=fopen(get_log_name(),"at"); if(F){ fprintf(F,buf); fclose(F); } }
int op_open(mval *device, mval *devparms, int timeout, mval *mspace) { char buf1[MAX_TRANS_NAME_LEN]; /* buffer to hold translated name */ io_log_name *naml; /* logical record for passed name */ io_log_name *tl; /* logical record for translated name */ io_log_name *prev; /* logical record for removal search */ int4 stat; /* status */ mstr tn; /* translated name */ DCL_THREADGBL_ACCESS; SETUP_THREADGBL_ACCESS; MV_FORCE_STR(device); MV_FORCE_STR(devparms); if (mspace) MV_FORCE_STR(mspace); if (timeout < 0) timeout = 0; else if (TREF(tpnotacidtime) < timeout) TPNOTACID_CHECK(OPENTIMESTR); assert((unsigned char)*devparms->str.addr < n_iops); naml = get_log_name(&device->str, INSERT); if (naml->iod != 0) tl = naml; else { # ifdef NOLICENSE licensed= TRUE; # else CRYPT_CHKSYSTEM; if (!licensed || LP_CONFIRM(lid, lkid)==LP_NOTACQ) licensed= FALSE; # endif switch(stat = TRANS_LOG_NAME(&device->str, &tn, &buf1[0], SIZEOF(buf1), dont_sendmsg_on_log2long)) { case SS_NORMAL: tl = get_log_name(&tn, INSERT); break; case SS_NOLOGNAM: tl = naml; break; default: for (prev = io_root_log_name, tl = prev->next; tl != 0; prev = tl, tl = tl->next) { if (naml == tl) { prev->next = tl->next; free(tl); break; } } # ifdef UNIX if (SS_LOG2LONG == stat) rts_error(VARLSTCNT(5) ERR_LOGTOOLONG, 3, device->str.len, device->str.addr, SIZEOF(buf1) - 1); else # endif rts_error(VARLSTCNT(1) stat); } } stat = io_open_try(naml, tl, devparms, timeout, mspace); return (stat); }
bool io_open_try(io_log_name *naml, io_log_name *tl, mval *pp, int4 timeout, mval *mspace) { char buf1[MAX_TRANS_NAME_LEN]; /* buffer to hold translated name */ char dev_type[MAX_DEV_TYPE_LEN]; int n; mstr tn; /* translated name */ uint4 stat; /* status */ int p_offset; unsigned char ch; ABS_TIME cur_time, end_time; bool out_of_time = FALSE; if (0 == naml->iod) { if (0 == tl->iod) { tl->iod = (io_desc *)malloc(SIZEOF(io_desc)); memset((char*)tl->iod, 0, SIZEOF(io_desc)); tl->iod->pair.in = tl->iod; tl->iod->pair.out = tl->iod; tl->iod->trans_name = tl; p_offset = 0; while (iop_eol != *(pp->str.addr + p_offset)) { if ((iop_tmpmbx == (ch = *(pp->str.addr + p_offset++))) || (iop_prmmbx == ch)) tl->iod->type = mb; else if (iop_nl == ch) tl->iod->type = nl; p_offset += ((IOP_VAR_SIZE == io_params_size[ch]) ? (unsigned char)*(pp->str.addr + p_offset) + 1 : io_params_size[ch]); } if (!tl->iod->type && mspace && mspace->str.len) { lower_to_upper(dev_type, mspace->str.addr, mspace->str.len); if (((SIZEOF("SOCKET") - 1) == mspace->str.len) && (0 == memcmp(dev_type, LIT_AND_LEN("SOCKET")))) tl->iod->type = gtmsocket; else tl->iod->type = us; } if (!tl->iod->type) { tn.len = tl->len; tn.addr = &tl->dollar_io; tl->iod->type = io_type(&tn); } } naml->iod = tl->iod; } tl->iod->disp_ptr = &io_dev_dispatch[tl->iod->type]; assert(0 != naml->iod); active_device = naml->iod; if (dev_never_opened == naml->iod->state) { naml->iod->wrap = DEFAULT_IOD_WRAP; naml->iod->width = DEFAULT_IOD_WIDTH; naml->iod->length = DEFAULT_IOD_LENGTH; naml->iod->write_filter = write_filter; } if (dev_open != naml->iod->state) { naml->iod->dollar.x = 0; naml->iod->dollar.y = 0; naml->iod->dollar.za = 0; naml->iod->dollar.zb[0] = 0; naml->iod->dollar.zeof = FALSE; } if (0 == timeout) stat = (naml->iod->disp_ptr->open)(naml, pp, -1, mspace, timeout); /* ZY: add a parameter timeout */ else if (NO_M_TIMEOUT == timeout) { while (FALSE == (stat = (naml->iod->disp_ptr->open)(naml, pp, -1, mspace, timeout))) /* ZY: add timeout */ { hiber_start(1000); /* 1 second */ if (outofband) outofband_action(FALSE); } } else { sys_get_curr_time(&cur_time); add_int_to_abs_time(&cur_time, timeout * 1000, &end_time); while (FALSE == (stat = (naml->iod->disp_ptr->open)(naml, pp, -1, mspace, timeout)) /* ZY: add timeout */ && (!out_of_time)) { hiber_start(1000); /* 1 second */ if (outofband) outofband_action(FALSE); sys_get_curr_time(&cur_time); if (abs_time_comp(&end_time, &cur_time) <= 0) out_of_time = TRUE; } } if (TRUE == stat) { naml->iod->state = dev_open; if (27 == naml->iod->trans_name->dollar_io[0]) { tn.addr = &naml->iod->trans_name->dollar_io[4]; n = naml->iod->trans_name->len - 4; if (n < 0) n = 0; tn.len = n; naml->iod->trans_name = get_log_name(&tn, INSERT); naml->iod->trans_name->iod = naml->iod; } } else { if (dev_open == naml->iod->state && (gtmsocket != naml->iod->type)) naml->iod->state = dev_closed; else if ((gtmsocket == naml->iod->type) && naml->iod->newly_created) { assert(naml->iod->state != dev_open); iosocket_destroy(naml->iod); } } active_device = 0; if ((NO_M_TIMEOUT != timeout) && IS_MCODE_RUNNING) return (stat); return FALSE; }
short iorm_open(io_log_name *iol, mval *pp, int fd, mval *mspace, int4 timeout) { int4 status; io_desc *iod; /* local pointer to io_curr_device */ d_rm_struct *d_rm; struct XABFHC xabfhc; struct XABPRO xabpro; struct RAB *r; struct FAB *f; struct NAM *nam; mstr newtln; struct dsc$descriptor_s devname, outname; uint4 width; uint4 acebin[128]; /* needs to be big enough for any other ACLs on file */ uint4 *acebinptr; struct acedef *aceptr; char *acetop; boolean_t acefound = FALSE, created = FALSE, isdisk = FALSE, noacl = FALSE; unsigned int devclass, devchar, devchar2, devtype, dvistat, iosb[2]; short devclassret, devcharret, devchar2ret, devtyperet; struct { item_list_3 item[4]; int terminator; } item_list; unsigned char resultant_name[255]; unsigned char tmpfdns; /** unsigned char resultant_name[MAX_TRANS_NAME_LEN]; THIS WOULD BE RIGHT BUT MAX_TRANS_NAME_LEN MUST BE <= 255 **/ /* while sr_unix/iorm_open.c prefixes errors with ERR_DEVOPENFAIL and it might be nice to be consistent */ /* changing VMS after all this time could break user programs */ /* An exception is being made for the extremely unlikely problem creating a GTM ACE so it stands out */ iod = iol->iod; assert(*(pp->str.addr) < n_iops); assert(iod); assert(iod->state >= 0 && iod->state < n_io_dev_states); assert(rm == iod->type); if (dev_never_opened == iod->state) { iod->dev_sp = (d_rm_struct *)(malloc(SIZEOF(d_rm_struct))); d_rm = (d_rm_struct *)iod->dev_sp; memset(d_rm, 0, SIZEOF(*d_rm)); iod->width = DEF_RM_WIDTH; iod->length = DEF_RM_LENGTH; r = &d_rm->r; f = &d_rm->f; *r = cc$rms_rab; *f = cc$rms_fab; r->rab$l_fab = f; r->rab$w_usz = d_rm->l_usz = DEF_RM_WIDTH; f->fab$w_mrs = d_rm->l_mrs = DEF_RM_WIDTH; f->fab$b_rfm = d_rm->b_rfm = FAB$C_VAR; /* default is variable record format */ f->fab$l_fop = FAB$M_CIF | FAB$M_SQO | FAB$M_CBT | FAB$M_NAM; f->fab$b_fac = FAB$M_GET | FAB$M_PUT | FAB$M_TRN; /* TRN allows truncate option to be specified in RAB later */ f->fab$b_rat = FAB$M_CR; f->fab$l_dna = DFLT_FILE_EXT; f->fab$b_dns = SIZEOF(DFLT_FILE_EXT) - 1; d_rm->f.fab$l_nam = nam = malloc(SIZEOF(*nam)); *nam = cc$rms_nam; nam->nam$l_esa = resultant_name; nam->nam$b_ess = SIZEOF(resultant_name); nam->nam$b_nop = NAM$M_NOCONCEAL; r->rab$l_rop = RAB$M_TMO | RAB$M_WBH | RAB$M_RAH; d_rm->promask = 0xFFFF; } else { d_rm = (d_rm_struct *)iod->dev_sp; if (dev_closed == iod->state) d_rm->f.fab$w_bls = 0; /* Reset the block size to pass the block-record check below. * The FAB initialization sets the block size later so it's OK to zero it here. */ nam = d_rm->f.fab$l_nam; nam->nam$l_esa = 0; nam->nam$b_ess = 0; nam->nam$b_esl = 0; } iorm_use(iod, pp); if (dev_open != iod->state) { if (!d_rm->largerecord && (d_rm->f.fab$w_bls > 0) && (FAB$C_FIX != d_rm->f.fab$b_rfm) && (d_rm->f.fab$w_bls < (d_rm->r.rab$w_usz + VREC_HDR_LEN))) rts_error(VARLSTCNT(1) ERR_VARRECBLKSZ); d_rm->r.rab$l_ctx = FAB$M_GET; d_rm->f.fab$l_fna = iol->dollar_io; d_rm->f.fab$b_fns = iol->len; /* smw next overrides any xab set by iorm_use */ xabpro = cc$rms_xabpro; d_rm->f.fab$l_xab = &xabpro; memset(acebin, 0, SIZEOF(acebin)); status = sys$parse(&d_rm->f); /* to get device for getdvi */ if ((1 & status)) { devname.dsc$w_length = nam->nam$b_dev; devname.dsc$a_pointer = nam->nam$l_dev; devname.dsc$b_dtype = DSC$K_DTYPE_T; devname.dsc$b_class = DSC$K_CLASS_S; item_list.item[0].item_code = DVI$_DEVCLASS; item_list.item[0].buffer_length = SIZEOF(devclass); item_list.item[0].buffer_address = &devclass; item_list.item[0].return_length_address = &devclassret; item_list.item[1].item_code = DVI$_DEVCHAR; item_list.item[1].buffer_length = SIZEOF(devchar); item_list.item[1].buffer_address = &devchar; item_list.item[1].return_length_address = &devcharret; item_list.item[2].item_code = DVI$_DEVCHAR2; item_list.item[2].buffer_length = SIZEOF(devchar2); item_list.item[2].buffer_address = &devchar2; item_list.item[2].return_length_address = &devchar2ret; item_list.item[3].item_code = DVI$_DEVTYPE; item_list.item[3].buffer_length = SIZEOF(devtype); item_list.item[3].buffer_address = &devtype; item_list.item[3].return_length_address = &devtyperet; item_list.terminator = 0; dvistat = sys$getdviw(EFN$C_ENF, NULL, &devname, &item_list, iosb, NULL, 0, 0); if (SS$_NORMAL == dvistat) dvistat = iosb[0]; if (SS$_NONLOCAL == dvistat || (SS$_NORMAL == dvistat && ((DC$_DISK != devclass || (DEV$M_NET & devchar) || (DEV$M_DAP | DEV$M_DFS) & devchar2) || /* UCX NFS sets DFS */ (DT$_FD1 <= devtype && DT$_FD8 >= devtype) ))) /* but not tcpware so check foreign disk */ { /* if not disk, dfs/nfs, or non local, create gets BADATTRIB in stv if acl buf and siz set */ noacl = TRUE; } } else /* let create/open report the problem */ noacl = TRUE; if (DEV$M_NET & d_rm->f.fab$l_dev) { /* need to release sys$parse channel if DECnet */ tmpfdns = d_rm->f.fab$b_dns; d_rm->f.fab$b_dns = 0; assert(0 == nam->nam$l_rlf); nam->nam$l_rlf = 0; nam->nam$b_nop |= NAM$M_SYNCHK; status = sys$parse(&d_rm->f); /* give up channel */ d_rm->f.fab$b_dns = tmpfdns; /* restore */ nam->nam$b_nop &= ~NAM$M_SYNCHK; } if (noacl) { if (d_rm->largerecord && MAX_RMS_RECORDSIZE < d_rm->l_mrs) rts_error(VARLSTCNT(1) ERR_RMWIDTHTOOBIG); d_rm->largerecord = FALSE; } if (d_rm->largerecord && FAB$M_GET != d_rm->f.fab$b_fac) { /* if readonly use format from existing file */ aceptr = acebin; aceptr->ace$b_size = GTM_ACE_SIZE * SIZEOF(uint4); aceptr->ace$b_type = ACE$C_INFO; /* without NOPROPAGATE, new versions will get ACE, PROTECTED prevents set acl /dele unless =all */ aceptr->ace$w_flags = ACE$M_NOPROPAGATE | ACE$M_PROTECTED; /* if HIDDEN, dir/sec does not display which may make it harder to check if problems aceptr->ace$w_flags |= ACE$M_HIDDEN; */ aceptr->ace$v_info_type = ACE$C_CUST; /* must be after flags */ aceptr->ace$w_application_facility = GTM_ACE_FAC; /* GTM error fac */ aceptr->ace$w_application_flags = GTM_ACE_BIGREC; assert(SIZEOF(uint4) * GTM_ACE_LAB_OFF == (&aceptr->ace$t_info_start - (char *)aceptr)); acebin[GTM_ACE_LAB_OFF] = GTM_ACE_LABEL; acebin[GTM_ACE_RFM_OFF] = d_rm->b_rfm; acebin[GTM_ACE_MRS_OFF] = d_rm->l_mrs; acebin[GTM_ACE_SIZE] = 0; /* terminate */ d_rm->f.fab$b_rfm = FAB$C_UDF; d_rm->f.fab$w_mrs = 0; } if (!noacl) { /* tape gets BADATTRIB in stv if acl buf and siz set */ xabpro.xab$l_aclbuf = acebin; xabpro.xab$w_aclsiz = SIZEOF(acebin); } if (FAB$M_GET == d_rm->f.fab$b_fac) { xabfhc = cc$rms_xabfhc; xabpro.xab$l_nxt = &xabfhc; status = sys$open(&d_rm->f); } else { xabpro.xab$w_pro = d_rm->promask; status = sys$create(&d_rm->f); } nam->nam$l_esa = 0; nam->nam$b_ess = 0; nam->nam$b_esl = 0; d_rm->f.fab$l_xab = 0; switch (status) { case RMS$_NORMAL: if (d_rm->f.fab$l_fop & FAB$M_MXV) created = iod->dollar.zeof = TRUE; break; case RMS$_CRE_STM: case RMS$_CREATED: case RMS$_SUPERSEDE: case RMS$_FILEPURGED: if (d_rm->f.fab$l_dev & DEV$M_FOD) created = iod->dollar.zeof = TRUE; break; case RMS$_ACT: case RMS$_FLK: return(FALSE); default: rts_error(VARLSTCNT(2) status, d_rm->f.fab$l_stv); } if (!noacl && (DEV$M_RND & d_rm->f.fab$l_dev) && !(DEV$M_NET & d_rm->f.fab$l_dev)) isdisk = TRUE; /* local disk */ else if (created && d_rm->largerecord && MAX_RMS_RECORDSIZE < d_rm->l_mrs) rts_error(VARLSTCNT(1) ERR_RMWIDTHTOOBIG); /* $create does not return the ACE: if a new file is created aclsts is IVACL */ /* if CIF and existing file has no acl aclsts ACLEMPTY */ /* if CIF and existing file has acl aclsts is NORMAL */ if (isdisk && ((created && SS$_IVACL == xabpro.xab$l_aclsts) || (0 != xabpro.xab$l_aclsts && (FAB$M_GET != d_rm->f.fab$b_fac && ((1 & xabpro.xab$l_aclsts) || SS$_ACLEMPTY != xabpro.xab$l_aclsts))))) { xabpro.xab$l_aclctx = 0; /* reset context */ d_rm->f.fab$l_xab = &xabpro; status = sys$display(&d_rm->f); d_rm->f.fab$l_xab = 0; /* prevent close error */ if (!(1 & status)) rts_error(VARLSTCNT(2) status, d_rm->f.fab$l_stv); if (0 != xabpro.xab$l_aclsts && !(1 & xabpro.xab$l_aclsts) && SS$_ACLEMPTY != xabpro.xab$l_aclsts) rts_error(VARLSTCNT(1) xabpro.xab$l_aclsts); } if (isdisk && (1 & status) && 0 != xabpro.xab$l_aclsts && !(1 & xabpro.xab$l_aclsts) && SS$_ACLEMPTY != xabpro.xab$l_aclsts) rts_error(VARLSTCNT(1) xabpro.xab$l_aclsts); if (isdisk && 0 != xabpro.xab$w_acllen && (1 & status)) /* acl and success */ { if (SIZEOF(acebin) < xabpro.xab$w_acllen) { /* get a new buffer big enough */ xabpro.xab$l_aclbuf = malloc(xabpro.xab$w_acllen); xabpro.xab$w_aclsiz = xabpro.xab$w_acllen; xabpro.xab$l_aclctx = 0; /* reset context */ d_rm->f.fab$l_xab = &xabpro; status = sys$display(&d_rm->f); d_rm->f.fab$l_xab = 0; if (!(1 & status)) rts_error(VARLSTCNT(2) status, d_rm->f.fab$l_stv); if (!(1 & xabpro.xab$l_aclsts)) rts_error(VARLSTCNT(1) xabpro.xab$l_aclsts); } acetop = (char *)xabpro.xab$l_aclbuf + xabpro.xab$w_acllen; for (aceptr = xabpro.xab$l_aclbuf; aceptr < acetop; aceptr = (char *)aceptr + aceptr->ace$b_size) { if (0 == aceptr->ace$b_size) break; if (ACE$C_INFO == aceptr->ace$b_type && ACE$C_CUST == aceptr->ace$v_info_type && GTM_ACE_FAC == aceptr->ace$w_application_facility && GTM_ACE_BIGREC == aceptr->ace$w_application_flags) { /* info for large records */ acebinptr = aceptr; assert(GTM_ACE_LABEL == acebinptr[GTM_ACE_LAB_OFF]); d_rm->largerecord = TRUE; d_rm->b_rfm = (unsigned char)acebinptr[GTM_ACE_RFM_OFF]; d_rm->l_mrs = acebinptr[GTM_ACE_MRS_OFF]; acefound = TRUE; break; } } if (acebin != xabpro.xab$l_aclbuf) { /* free larger buffer now */ free(xabpro.xab$l_aclbuf); xabpro.xab$l_aclbuf = acebin; xabpro.xab$w_aclsiz = SIZEOF(acebin); } } if (!acefound) { if (!created) { /* copy from exisiting file */ if (isdisk && d_rm->largerecord && FAB$C_UDF == d_rm->f.fab$b_rfm) rts_error(VARLSTCNT(1) ERR_BIGNOACL); /* maybe lost in copy */ d_rm->b_rfm = d_rm->f.fab$b_rfm; d_rm->l_mrs = d_rm->f.fab$w_mrs; } else if (isdisk && d_rm->largerecord) rts_error(VARLSTCNT(8) ERR_DEVOPENFAIL, 2, iol->len, iol->dollar_io, ERR_TEXT, 2, LEN_AND_LIT("GTM ACE on new file disappeared - possible VMS problem")); d_rm->largerecord = FALSE; } /* smw does next overwriting of mrs make sense to RMS */ /* if not largerecord, read only, sequential, not magtape ... */ if (!d_rm->largerecord && (FAB$M_GET == d_rm->f.fab$b_fac) && (0 == d_rm->f.fab$w_mrs) && xabfhc.xab$w_lrl) d_rm->l_mrs = d_rm->l_usz = d_rm->r.rab$w_usz = d_rm->f.fab$w_mrs = xabfhc.xab$w_lrl; if (d_rm->largerecord) { /* guess at a good blocks per IO */ uint4 blocksperrec; blocksperrec = DIVIDE_ROUND_UP(d_rm->l_mrs, RMS_DISK_BLOCK); if (RMS_MAX_MBC <= blocksperrec * 2) d_rm->r.rab$b_mbc = RMS_MAX_MBC; else if (RMS_DEF_MBC < blocksperrec * 2) d_rm->r.rab$b_mbc = blocksperrec * 2; } status = sys$connect(&d_rm->r); if (RMS$_NORMAL != status) rts_error(VARLSTCNT(2) status, d_rm->r.rab$l_stv); if (d_rm->r.rab$l_rop & RAB$M_EOF) iod->dollar.zeof = TRUE; if (ESC == iod->trans_name->dollar_io[0]) { /* process permanent file...get real name */ status = sys$display(&d_rm->f); if (status & 1) { devname.dsc$w_length = nam->nam$t_dvi[0]; devname.dsc$b_dtype = DSC$K_DTYPE_T; devname.dsc$b_class = DSC$K_CLASS_S; devname.dsc$a_pointer = &nam->nam$t_dvi[1]; outname.dsc$w_length = SIZEOF(resultant_name); outname.dsc$b_dtype = DSC$K_DTYPE_T; outname.dsc$b_class = DSC$K_CLASS_S; outname.dsc$a_pointer = resultant_name; status = lib$fid_to_name(&devname, &nam->nam$w_fid, & outname, &newtln.len, 0, 0); if ((status & 1) && (0 != newtln.len)) { newtln.addr = resultant_name; iod->trans_name = get_log_name(&newtln, INSERT); iod->trans_name->iod = iod; } } } else { /* smw since esl zeroed above this is dead code since early days */ if (nam->nam$b_esl && (iod->trans_name->len != nam->nam$b_esl || memcmp(&iod->trans_name->dollar_io[0], resultant_name, nam->nam$b_esl))) { newtln.addr = resultant_name; newtln.len = nam->nam$b_esl; iod->trans_name = get_log_name(&newtln, INSERT); iod->trans_name->iod = iod; } } if (0 == d_rm->l_mrs) d_rm->l_mrs = iod->width; iod->width = d_rm->l_usz = d_rm->l_mrs; if (!d_rm->largerecord) { d_rm->r.rab$w_usz = d_rm->f.fab$w_mrs = d_rm->l_mrs; if (FAB$C_VFC == d_rm->f.fab$b_rfm) /* have to leave two bytes for the fixed control */ iod->width = MIN(iod->width, VFC_MAX_RECLEN); } width = iod->width; if (d_rm->largerecord) { width = ROUND_UP(width, SIZEOF(uint4)); if (FAB$C_VAR == d_rm->b_rfm) width += SIZEOF(uint4); /* for count */ } d_rm->bufsize = width + 1; d_rm->inbuf = (char*)malloc(width + 1); d_rm->outbuf_start = (char*)malloc(width + 1); d_rm->inbuf_pos = d_rm->inbuf; d_rm->inbuf_top = d_rm->inbuf + iod->width; d_rm->outbuf_pos = d_rm->outbuf = d_rm->outbuf_start + (d_rm->largerecord && FAB$C_VAR == d_rm->b_rfm ? SIZEOF(uint4) : 0); d_rm->outbuf_top = d_rm->outbuf + iod->width; d_rm->promask = xabpro.xab$w_pro; iod->state = dev_open; } return TRUE; }
static ssize_t bcmlog_ap_crash_show(struct device *dev, struct device_attribute *attr, char *buf) { return snprintf(buf, MAX_STR_NAME + 1, "%s\n", get_log_name(g_config.ap_crashlog.dev)); }
void op_use(mval *v, mval *p) { char buf1[MAX_TRANS_NAME_LEN]; /* buffer to hold translated name */ io_log_name *nl; /* logical record for passed name */ io_log_name *tl; /* logical record for translated name */ int4 stat; /* status */ mstr tn; /* translated name */ int dollar_zpselect; /* 0 - both, 1 - input only, 2 - output only */ char *c1; /* used to compare $P name */ int nlen; /* len of $P name */ io_log_name *tlp; /* logical record for translated name for $principal */ MV_FORCE_STR(v); MV_FORCE_STR(p); dollar_zpselect = 0; if (io_std_device->in != io_std_device->out) { /* if there is a split $P then determine from the name if it is the value of "$P< /" or "$P> /" if the first then it is $ZPIN so set dollar_zpselect to 1 if the second then it is $ZPOUT so set dollar_zpselect to 2 else set dollar_zpselect to 0 if it is $ZPIN or $ZPOUT get the log_name for $P into nl else use the mval v passed in */ tlp = dollar_principal ? dollar_principal : io_root_log_name->iod->trans_name; nlen = tlp->len; assert(dollar_zpout.len == dollar_zpin.len); if ((nlen + dollar_zpin.len) == v->str.len) { /* passed the length test now compare the 2 pieces, the first one the length of $P and the second $ZPIN or $ZPOUT */ c1 = (char *)tlp->dollar_io; if (!memvcmp(c1, nlen, &(v->str.addr[0]), nlen)) { if (!memvcmp(dollar_zpin.addr, dollar_zpin.len, &(v->str.addr[nlen]), dollar_zpin.len)) dollar_zpselect = 1; else if (!memvcmp(dollar_zpout.addr, dollar_zpout.len, &(v->str.addr[nlen]), dollar_zpout.len)) dollar_zpselect = 2; } } } if (0 == dollar_zpselect) nl = get_log_name(&v->str, NO_INSERT); else nl = get_log_name(&dollar_prin_log, NO_INSERT); if (!nl) { stat = TRANS_LOG_NAME(&v->str, &tn, buf1, SIZEOF(buf1), do_sendmsg_on_log2long); if (stat != SS_NORMAL) rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_IONOTOPEN); else { if ((tl = get_log_name(&tn, NO_INSERT)) == 0) rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_IONOTOPEN); if (!tl->iod) rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_IONOTOPEN); nl = get_log_name(&v->str, INSERT); nl->iod = tl->iod; } } if (nl->iod->state != dev_open) rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_IONOTOPEN); if (dollar_principal && nl->iod == dollar_principal->iod) { /* if device is a GTM_PRINCIPAL synonym */ nl = dollar_principal; } else { /* special case U "" , U 0, U $ZPIN, U $ZPOUT to be equivalent to U $P */ /* $ZPIN or $ZPOUT force nl to "0" */ /* note: "" is always the root */ if (nl == io_root_log_name || ((1 == nl->len) && ('0' == nl->dollar_io[0]))) nl = nl->iod->trans_name; } active_device = nl->iod; io_curr_device = nl->iod->pair; io_curr_device.in->name = nl; if (nl->iod->pair.in == nl->iod->pair.out) (nl->iod->disp_ptr->use)(nl->iod, p); else { if (2 != dollar_zpselect) (nl->iod->disp_ptr->use)(nl->iod, p); if (1 != dollar_zpselect) (nl->iod->pair.out->disp_ptr->use)(nl->iod->pair.out, p); } active_device = 0; return; }
void io_init(bool term_ctrl) { static readonly unsigned char open_params_list[2] = { (unsigned char)iop_newversion, (unsigned char)iop_eol }; static readonly unsigned char null_params_list[2] = { (unsigned char)iop_nl, (unsigned char)iop_eol }; static readonly unsigned char no_params = (unsigned char)iop_eol; static readonly unsigned char shr_params[3] = { (unsigned char)iop_shared, (unsigned char)iop_readonly, (unsigned char)iop_eol }; int4 status; mval val; mstr tn; MSTR_CONST (gtm_netout, "GTM_NETOUT"); MSTR_CONST (sys_net, "SYS$NET"); char buf1[MAX_TRANS_NAME_LEN]; /* buffer to hold translated name */ mval pars; io_log_name *inp, *outp; io_log_name *ln; error_def(ERR_LOGTOOLONG); io_init_name(); /* default logical names */ io_root_log_name = (io_log_name *)malloc(SIZEOF(*io_root_log_name)); memset(io_root_log_name, 0, SIZEOF(*io_root_log_name)); val.mvtype = MV_STR; val.str.addr = "0"; val.str.len = 1; ln = get_log_name(&val.str, INSERT); assert(ln != 0); val.str = gtm_principal; status = TRANS_LOG_NAME(&val.str, &tn, buf1, SIZEOF(buf1), dont_sendmsg_on_log2long); if (SS_NOLOGNAM == status) dollar_principal = 0; else if (SS_NORMAL == status) dollar_principal = get_log_name(&tn, INSERT); # ifdef UNIX else if (SS_LOG2LONG == status) rts_error(VARLSTCNT(5) ERR_LOGTOOLONG, 3, val.str.len, val.str.addr, SIZEOF(buf1) - 1); # endif else rts_error(VARLSTCNT(1) status); /* open devices */ val.str = sys_input; inp = get_log_name(&val.str, INSERT); pars.mvtype = MV_STR; status = TRANS_LOG_NAME(&val.str, &tn, buf1, SIZEOF(buf1), dont_sendmsg_on_log2long); if (SS_NOLOGNAM == status) { pars.str.len = SIZEOF(null_params_list); pars.str.addr = (char *)null_params_list; } else if (SS_NORMAL == status) { if (!io_is_rm(&val.str)) { pars.str.len = SIZEOF(no_params); pars.str.addr = (char *)&no_params; } else if (io_is_sn(&val.str)) { pars.str.len = SIZEOF(open_params_list); pars.str.addr = (char *)open_params_list; } else { pars.str.len = SIZEOF(shr_params); pars.str.addr = (char *)shr_params; } } # ifdef UNIX else if (SS_LOG2LONG == status) rts_error(VARLSTCNT(5) ERR_LOGTOOLONG, 3, val.str.len, val.str.addr, SIZEOF(buf1) - 1); # endif else rts_error(VARLSTCNT(1) status); ESTABLISH(io_init_ch); (*op_open_ptr)(&val, &pars, 0, 0); io_curr_device.in = io_std_device.in = inp->iod; val.str = sys_output; if ((SS_NORMAL == TRANS_LOG_NAME(>m_netout, &tn, buf1, SIZEOF(buf1), do_sendmsg_on_log2long)) && (SS_NORMAL == TRANS_LOG_NAME(&sys_net, &tn, buf1, SIZEOF(buf1), do_sendmsg_on_log2long)) && io_is_sn(&sys_net)) val.str = sys_net; outp = get_log_name(&val.str, INSERT); status = TRANS_LOG_NAME(&val.str, &tn, buf1, SIZEOF(buf1), dont_sendmsg_on_log2long); if ((SS_NORMAL != status) && (SS_NOLOGNAM != status)) { # ifdef UNIX if (SS_LOG2LONG == status) rts_error(VARLSTCNT(5) ERR_LOGTOOLONG, 3, val.str.len, val.str.addr, SIZEOF(buf1) - 1); else # endif rts_error(VARLSTCNT(1) status); } if ((val.str.addr == sys_net.addr) && (pars.str.addr == (char *)open_params_list)) /* sys$net is the only input thing that uses open_params_list */ outp->iod = io_curr_device.in; /* For terminals and mailboxes and sockets, SYS$INPUT and SYS$OUTPUT may point to the same device. If input is one of those, then check translated name for output against translated name for input; in that case they should be joined by their logical names */ if (((tt == io_curr_device.in->type) || (mb == io_curr_device.in->type) || (gtmsocket == io_curr_device.in->type)) && same_device_check(tn, buf1)) outp->iod = io_curr_device.in; if (!outp->iod) { if (status == SS_NOLOGNAM) { pars.str.len = SIZEOF(null_params_list); pars.str.addr = (char *)null_params_list; } else if (status == SS_NORMAL) { pars.str.len = SIZEOF(open_params_list); pars.str.addr = (char *)open_params_list; } (*op_open_ptr)(&val, &pars, 0, 0); } io_curr_device.out = io_std_device.out = outp->iod; term_setup(term_ctrl); io_std_device.out->pair = io_std_device; io_std_device.in->pair = io_std_device; io_std_device.out->perm = io_std_device.in->perm = TRUE; for (ln = io_root_log_name; ln; ln = ln->next) ln->iod = io_std_device.in; if (dollar_principal) dollar_principal->iod = io_std_device.in; pars.str.len = SIZEOF(no_params); pars.str.addr = (char *)&no_params; val.str.len = io_curr_device.in->trans_name->len; val.str.addr = io_std_device.in->trans_name->dollar_io; op_use(&val, &pars); REVERT; return; }